forked from xhgit/webup-cloud
144 lines
8.9 KiB
Python
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()
|