Files
webup-cloud/node-agent/domain_runtime.py
T
WebUp Cloud db82325ed7
Verify control plane / verify (push) Canceled after 0s
Initial import of WebUp Cloud
2026-11-07 13:31:14 +08:00

144 lines
8.9 KiB
Python

"""Platform-owned Ingress and cert-manager resources; never executes tenant code."""
import os
import re
import threading
import uuid
from datetime import datetime, timezone
from fastapi import APIRouter, Header, HTTPException
from kubernetes import client
from kubernetes.client.rest import ApiException
from pydantic import BaseModel, Field
from runtime import NAMESPACE, auth, blocked, guard, locks
router = APIRouter()
class DomainRoute(BaseModel):
projectId: uuid.UUID
serviceId: uuid.UUID
hostname: str = Field(min_length=3, max_length=253)
generation: int = Field(ge=1)
port: int = Field(default=80, ge=1, le=65535)
remove: bool = False
def hostname(value):
if value != value.lower() or '.' not in value or re.fullmatch(r'[0-9.]+', value):
raise HTTPException(400, 'Invalid domain hostname')
if any(not re.fullmatch(r'[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?', label) for label in value.split('.')):
raise HTTPException(400, 'Invalid domain hostname')
return value
def metadata(resource):
return resource.get('metadata', {}) if isinstance(resource, dict) else resource.metadata.to_dict()
def owned(resource, identity, generation):
meta = metadata(resource)
if (meta.get('labels') or {}).get('platform/domain') != identity:
raise HTTPException(409, 'Existing resource is not owned by this domain binding')
if int((meta.get('annotations') or {}).get('platform/generation', '0')) > generation:
raise HTTPException(409, 'Stale domain operation')
def upsert(create, read, patch, body, identity, generation):
try:
return create(body)
except ApiException as error:
if error.status != 409:
raise
current = read()
owned(current, identity, generation)
meta = metadata(current)
body['metadata']['resourceVersion'] = meta.get('resourceVersion', meta.get('resource_version'))
current_spec = current.get('spec') if isinstance(current, dict) else None
if current_spec == body['spec'] and (meta.get('annotations') or {}).get('platform/generation') == str(generation):
return current
return patch(body)
def certificate_ready(certificate, host, secret):
spec, status = certificate.get('spec', {}), certificate.get('status', {})
if host not in spec.get('dnsNames', []) or spec.get('secretName') != secret:
return False
generation = certificate.get('metadata', {}).get('generation')
if not isinstance(generation, int) or generation < 1:
return False
if not any(c.get('type') == 'Ready' and c.get('status') == 'True' and c.get('observedGeneration') == generation for c in status.get('conditions', [])):
return False
try:
return datetime.fromisoformat(status['notAfter'].replace('Z', '+00:00')) > datetime.now(timezone.utc)
except (KeyError, ValueError, TypeError):
return False
def delete_owned(read, delete, identity, generation):
try:
resource = read()
owned(resource, identity, generation)
meta = metadata(resource)
delete({'preconditions': {'uid': meta.get('uid'), 'resourceVersion': meta.get('resourceVersion', meta.get('resource_version'))}})
except ApiException as error:
if error.status != 404:
raise
@router.post('/runtime/domains/{domain}')
def apply_domain(domain: uuid.UUID, request: DomainRoute, authorization: str | None = Header(default=None)):
auth(authorization)
identity, project = domain.hex, request.projectId.hex
host = hostname(request.hostname)
name, secret = 'domain-' + identity, 'domain-' + identity + '-tls'
with guard:
lock = locks.setdefault('route-' + identity, threading.Lock())
if not lock.acquire(timeout=1):
raise HTTPException(409, 'Domain operation in progress')
core, network, custom = client.CoreV1Api(), client.NetworkingV1Api(), client.CustomObjectsApi()
try:
receipt_name = 'route-' + identity
try:
receipt = core.read_namespaced_config_map(receipt_name, NAMESPACE)
data = receipt.data or {}
if data.get('project') != project or data.get('hostname') != host:
raise HTTPException(409, 'Domain receipt owner conflict')
if int(data.get('generation', '0')) > request.generation or (int(data.get('generation', '0')) == request.generation and data.get('desired') == 'REMOVED' and not request.remove):
raise HTTPException(409, 'Stale domain operation')
core.patch_namespaced_config_map(receipt_name, NAMESPACE, {'metadata': {'resourceVersion': receipt.metadata.resource_version}, 'data': {'generation': str(request.generation), 'desired': 'REMOVED' if request.remove else 'ACTIVE'}})
except ApiException as error:
if error.status != 404:
raise
core.create_namespaced_config_map(NAMESPACE, {'metadata': {'name': receipt_name}, 'data': {'project': project, 'hostname': host, 'generation': str(request.generation), 'desired': 'REMOVED' if request.remove else 'ACTIVE'}})
cert_read = lambda: custom.get_namespaced_custom_object('cert-manager.io', 'v1', NAMESPACE, 'certificates', name)
if request.remove:
delete_owned(lambda: network.read_namespaced_ingress(name, NAMESPACE), lambda body: network.delete_namespaced_ingress(name, NAMESPACE, body=body), identity, request.generation)
delete_owned(cert_read, lambda body: custom.delete_namespaced_custom_object('cert-manager.io', 'v1', NAMESPACE, 'certificates', name, body=body), identity, request.generation)
# Only a secret labelled by our Certificate secretTemplate is eligible for removal.
delete_owned(lambda: core.read_namespaced_secret(secret, NAMESPACE), lambda body: core.delete_namespaced_secret(secret, NAMESPACE, body=body), identity, request.generation)
return {'removed': True, 'generation': request.generation}
if blocked(core, project):
raise HTTPException(409, 'Project runtime is suspended')
issuer = os.environ.get('RUNTIME_TLS_ISSUER', '')
if not issuer:
raise HTTPException(503, 'Configure a cert-manager ClusterIssuer before domain provisioning')
stable = 'svc-' + request.serviceId.hex[:20]
service = core.read_namespaced_service(stable, NAMESPACE)
selected = service.spec.selector or {}
if selected.get('platform/project') != project or selected.get('platform/service') != request.serviceId.hex or not any(p.port == request.port for p in service.spec.ports or []):
raise HTTPException(409, 'Published service or port does not match this project')
meta = {'name': name, 'labels': {'platform/domain': identity, 'platform/project': project}, 'annotations': {'platform/generation': str(request.generation)}}
certificate = {'apiVersion': 'cert-manager.io/v1', 'kind': 'Certificate', 'metadata': dict(meta), 'spec': {'secretName': secret, 'dnsNames': [host], 'issuerRef': {'name': issuer, 'kind': 'ClusterIssuer'}, 'secretTemplate': {'labels': {'platform/domain': identity, 'platform/project': project}}}}
upsert(lambda body: custom.create_namespaced_custom_object('cert-manager.io', 'v1', NAMESPACE, 'certificates', body), cert_read, lambda body: custom.patch_namespaced_custom_object('cert-manager.io', 'v1', NAMESPACE, 'certificates', name, body), certificate, identity, request.generation)
ingress_meta = {**meta, 'annotations': {**meta['annotations'], 'nginx.ingress.kubernetes.io/ssl-redirect': 'true'}}
ingress = {'apiVersion': 'networking.k8s.io/v1', 'kind': 'Ingress', 'metadata': ingress_meta, 'spec': {'ingressClassName': os.environ.get('RUNTIME_INGRESS_CLASS', 'nginx'), 'tls': [{'hosts': [host], 'secretName': secret}], 'rules': [{'host': host, 'http': {'paths': [{'path': '/', 'pathType': 'Prefix', 'backend': {'service': {'name': stable, 'port': {'number': request.port}}}}]}}]}}
upsert(lambda body: network.create_namespaced_ingress(NAMESPACE, body), lambda: network.read_namespaced_ingress(name, NAMESPACE), lambda body: network.patch_namespaced_ingress(name, NAMESPACE, body), ingress, identity, request.generation)
current_ingress = network.read_namespaced_ingress(name, NAMESPACE)
pods = core.list_namespaced_pod(NAMESPACE, label_selector=','.join(k + '=' + v for k, v in selected.items())).items
has_pods = any(p.status.phase == 'Running' and p.status.container_statuses and all(c.ready for c in p.status.container_statuses) for p in pods)
route_ready = bool(current_ingress.status and current_ingress.status.load_balancer and current_ingress.status.load_balancer.ingress) and has_pods
return {'configured': True, 'routeReady': route_ready, 'tlsReady': certificate_ready(cert_read(), host, secret), 'generation': request.generation}
except ApiException:
raise HTTPException(503, 'Domain resources not ready; check ingress controller, cert-manager and gateway RBAC') from None
finally:
lock.release()