"""Pure, offline Kubernetes renderer for one internal test batch. The result is a review artifact, not an apply command. Credentials, source captures, and cluster state never enter this module. """ from __future__ import annotations import ipaddress import re from urllib.parse import urlsplit NAMESPACE = "droboticflow-internal-test" REQUIRED_SECRET_KEYS = ( "MONGO_ROOT_USERNAME", "MONGO_ROOT_PASSWORD", "MONGO_APP_USERNAME", "MONGO_APP_PASSWORD", "MONGO_URI", "DROBOTICFLOW_API_TOKEN", ) _PRODUCTION_HOSTS = {"120.48.180.80"} _CONFIG_KEYS = { "schemaVersion", "namespace", "batchId", "hostname", "productionOrigins", "image", "mongoImage", "buildCommit", "workspaceGi", "mongoGi", "resources", "storageClass", "tlsSecretName", "imagePullSecretName", "ingressNamespace", "ingressClassName", } _DNS_LABEL = re.compile(r"^[a-z](?:[a-z0-9-]*[a-z0-9])?$") _BATCH = re.compile(r"^[a-z](?:[a-z0-9-]{0,30}[a-z0-9])?$") _IMAGE = re.compile(r"^[^\s@]+@sha256:[0-9a-f]{64}$") _CPU = re.compile(r"^(?:[1-9][0-9]*m|[1-9][0-9]*)$") _MEM = re.compile(r"^([1-9][0-9]*)(Mi|Gi)$") def _required_string(value: object, field: str) -> str: if not isinstance(value, str) or not value or value != value.strip(): raise ValueError(f"{field} must be a nonblank string without surrounding whitespace") return value def _dns_label(value: object, field: str) -> str: value = _required_string(value, field) if len(value) > 63 or not _DNS_LABEL.fullmatch(value): raise ValueError(f"{field} must be a lowercase DNS label") return value def _quantity(value: object, field: str, *, cpu: bool) -> int: value = _required_string(value, field) if cpu: if not _CPU.fullmatch(value): raise ValueError(f"{field} must be an integer core or positive millicore quantity") return int(value[:-1]) if value.endswith("m") else 1000 * int(value) match = _MEM.fullmatch(value) if not match: raise ValueError(f"{field} must be a positive Mi or Gi quantity") return int(match[1]) * (1024 if match[2] == "Gi" else 1) def _origin_host(value: object) -> str: value = _required_string(value, "productionOrigins entry") parsed = urlsplit(value) if parsed.scheme not in ("http", "https") or not parsed.hostname or parsed.username or parsed.password: raise ValueError("productionOrigins must contain absolute HTTP(S) origins") if parsed.path not in ("", "/") or parsed.query or parsed.fragment: raise ValueError("productionOrigins entries must be origins without paths or queries") try: _ = parsed.port except ValueError as exc: raise ValueError("productionOrigins contains an invalid port") from exc return parsed.hostname.lower().rstrip(".") def validate_config(raw: dict) -> dict: """Reject ambiguous or unsafe deployment input and return derived names.""" if not isinstance(raw, dict): raise ValueError("config must be a JSON object") unknown = set(raw) - _CONFIG_KEYS - { "databaseName", "resourcePrefix", "credentialsSecretName", "mongoServiceName", "workspacePvcName", "mongoPvcName", } if unknown: raise ValueError(f"unknown config fields: {', '.join(sorted(unknown))}") if type(raw.get("schemaVersion")) is not int or raw["schemaVersion"] != 1: raise ValueError("schemaVersion must be 1") if raw.get("namespace", NAMESPACE) != NAMESPACE: raise ValueError(f"namespace must be {NAMESPACE}") batch = _required_string(raw.get("batchId"), "batchId") if not _BATCH.fullmatch(batch): raise ValueError("batchId must be 1-32 lowercase letters, digits, or hyphens") hostname = _required_string(raw.get("hostname"), "hostname").lower() if hostname != raw["hostname"] or hostname.endswith(".") or len(hostname) > 253: raise ValueError("hostname must be a lowercase DNS name") if len(hostname.split(".")) < 3 or any(not _DNS_LABEL.fullmatch(part) or len(part) > 63 for part in hostname.split(".")): raise ValueError("hostname must be a dedicated fully qualified DNS name") try: ipaddress.ip_address(hostname) except ValueError: pass else: raise ValueError("hostname cannot be an IP address") if hostname == "localhost" or hostname.endswith(".localhost"): raise ValueError("hostname cannot be localhost") origins = raw.get("productionOrigins") if not isinstance(origins, list) or not origins: raise ValueError("productionOrigins must be a nonempty list") origin_hosts = {_origin_host(origin) for origin in origins} if hostname in origin_hosts or hostname in _PRODUCTION_HOSTS: raise ValueError("hostname must not be a production origin") for field in ("image", "mongoImage"): if not _IMAGE.fullmatch(_required_string(raw.get(field), field)): raise ValueError(f"{field} must be pinned by a sha256 digest") commit = _required_string(raw.get("buildCommit"), "buildCommit") if not re.fullmatch(r"[0-9a-f]{40}", commit): raise ValueError("buildCommit must be a full 40-character lowercase Git SHA") for field, maximum in (("workspaceGi", 500), ("mongoGi", 100)): value = raw.get(field) if type(value) is not int or not 1 <= value <= maximum: raise ValueError(f"{field} must be an integer between 1 and {maximum}") resources = raw.get("resources") if not isinstance(resources, dict) or set(resources) != {"api", "processor", "mongo"}: raise ValueError("resources must specify api, processor, and mongo") for component, value in resources.items(): if not isinstance(value, dict) or set(value) != {"requests", "limits"}: raise ValueError(f"resources.{component} needs requests and limits") for category in ("requests", "limits"): quantities = value[category] if not isinstance(quantities, dict) or set(quantities) != {"cpu", "memory"}: raise ValueError(f"resources.{component}.{category} needs cpu and memory") for key, cpu in (("cpu", True), ("memory", False)): request = _quantity(value["requests"][key], f"resources.{component}.requests.{key}", cpu=cpu) limit = _quantity(value["limits"][key], f"resources.{component}.limits.{key}", cpu=cpu) maximum = (4000 if cpu else 8192) if component == "processor" else (2000 if cpu else 4096) if request > limit or limit > maximum: raise ValueError(f"resources.{component}.{key} request/limit exceeds the bounded lane") for field in ("tlsSecretName", "imagePullSecretName", "ingressNamespace"): _dns_label(raw.get(field), field) if "storageClass" in raw: _dns_label(raw["storageClass"], "storageClass") if "ingressClassName" in raw: _dns_label(raw["ingressClassName"], "ingressClassName") prefix = f"internal-test-{batch}" derived = { "namespace": NAMESPACE, "databaseName": "droboticflow_internal_test_" + batch.replace("-", "_"), "resourcePrefix": prefix, "credentialsSecretName": prefix + "-credentials", "mongoServiceName": prefix + "-mongo", "workspacePvcName": prefix + "-workspace", "mongoPvcName": prefix + "-mongo-data", } for field, expected in derived.items(): if field in raw and raw[field] != expected: raise ValueError(f"{field} must equal the batch-scoped derived value") result = dict(raw) result.update(derived) return result def render_environment(config: dict) -> dict: """Render one batch as a Kubernetes List; never talks to Kubernetes.""" c = validate_config(config) ns, prefix, db = c["namespace"], c["resourcePrefix"], c["databaseName"] secret, mongo = c["credentialsSecretName"], c["mongoServiceName"] labels = {"app.kubernetes.io/part-of": "droboticflow-internal-test", "internal-test/batch": c["batchId"]} def obj(api_version: str, kind: str, name: str, spec: dict | None = None, *, data: dict | None = None) -> dict: item = {"apiVersion": api_version, "kind": kind, "metadata": {"name": name, "namespace": ns, "labels": labels}} if spec is not None: item["spec"] = spec if data is not None: item["data"] = data return item def env(name: str, *, key: str | None = None, value: str | None = None) -> dict: if key is not None: return {"name": name, "valueFrom": {"secretKeyRef": {"name": secret, "key": key}}} return {"name": name, "value": value} def pod_spec(component: str, container: dict, *, workspace: bool = False, init: list | None = None) -> dict: spec = { "serviceAccountName": prefix + "-" + component, "automountServiceAccountToken": False, "imagePullSecrets": [{"name": c["imagePullSecretName"]}], "securityContext": {"runAsNonRoot": True, "runAsUser": 10001, "runAsGroup": 10001, "fsGroup": 10001, "seccompProfile": {"type": "RuntimeDefault"}}, "containers": [container], } if init: spec["initContainers"] = init if workspace: spec["volumes"] = [{"name": "workspace", "persistentVolumeClaim": {"claimName": c["workspacePvcName"]}}] return spec def deployment(component: str, container: dict, *, workspace: bool = False, init: list | None = None) -> dict: name = prefix + "-" + component selector = {"app": name} spec = { "replicas": 0, "strategy": {"type": "Recreate"}, "selector": {"matchLabels": selector}, "template": {"metadata": {"labels": {**labels, **selector}}, "spec": pod_spec(component, container, workspace=workspace, init=init)}, } return obj("apps/v1", "Deployment", name, spec) items = [{"apiVersion": "v1", "kind": "Namespace", "metadata": {"name": ns, "labels": {"app.kubernetes.io/part-of": "droboticflow-internal-test"}}}] for component in ("api", "processor", "mongo", "initializer"): items.append(obj("v1", "ServiceAccount", prefix + "-" + component)) items.append(obj("v1", "ConfigMap", prefix + "-config", data={ "MONGO_DB": db, "PORT": "3001", "WORKSPACE_MOUNT_PATH": "/workspace", "ANNOTATION_PROCESSOR_MODE": "external", "DROBOTICFLOW_REQUIRE_SESSION_AUTH": "true", "DROBOTICFLOW_SESSION_COOKIE_SECURE": "true", "DROBOTICFLOW_OBJECT_SYNC_ENABLED": "false", "K8S_NAMESPACE": ns, "WORKSPACE_PVC_NAME": c["workspacePvcName"], "DROBOTICFLOW_BUILD_COMMIT": c["buildCommit"], "INTERNAL_TEST_BATCH_ID": c["batchId"], "INTERNAL_TEST_ENVIRONMENT": "true", })) for kind, size in (("workspace", c["workspaceGi"]), ("mongo-data", c["mongoGi"])): name = c["workspacePvcName"] if kind == "workspace" else c["mongoPvcName"] pvc = obj("v1", "PersistentVolumeClaim", name, { "accessModes": ["ReadWriteMany" if kind == "workspace" else "ReadWriteOnce"], "resources": {"requests": {"storage": f"{size}Gi"}}, }) pvc["metadata"]["annotations"] = {"helm.sh/resource-policy": "keep", "internal-test/retention": "manual-review-only"} if "storageClass" in c: pvc["spec"]["storageClassName"] = c["storageClass"] items.append(pvc) mongo_bootstrap = ( "const name = process.env.MONGO_INITDB_DATABASE;\n" "if (!/^droboticflow_internal_test_[a-z0-9_]+$/.test(name)) throw Error('unsafe database name');\n" "db.getSiblingDB(name).createUser({user: process.env.MONGO_APP_USERNAME," " pwd: process.env.MONGO_APP_PASSWORD, roles: [{role: 'readWrite', db: name}]});\n" ) items.append(obj("v1", "ConfigMap", prefix + "-mongo-init", data={"01-create-app-user.js": mongo_bootstrap})) items.append(obj("v1", "Service", mongo, { "type": "ClusterIP", "selector": {"app": mongo}, "ports": [{"name": "mongo", "port": 27017, "targetPort": 27017}], })) mongo_container = { "name": "mongo", "image": c["mongoImage"], "imagePullPolicy": "IfNotPresent", "ports": [{"name": "mongo", "containerPort": 27017}], "env": [ env("MONGO_INITDB_DATABASE", value=db), env("MONGO_INITDB_ROOT_USERNAME", key="MONGO_ROOT_USERNAME"), env("MONGO_INITDB_ROOT_PASSWORD", key="MONGO_ROOT_PASSWORD"), env("MONGO_APP_USERNAME", key="MONGO_APP_USERNAME"), env("MONGO_APP_PASSWORD", key="MONGO_APP_PASSWORD"), ], "volumeMounts": [{"name": "data", "mountPath": "/data/db"}, {"name": "mongo-init", "mountPath": "/docker-entrypoint-initdb.d", "readOnly": True}], "resources": c["resources"]["mongo"], "securityContext": {"allowPrivilegeEscalation": False, "capabilities": {"drop": ["ALL"]}}, "readinessProbe": {"tcpSocket": {"port": "mongo"}, "periodSeconds": 10}, } mongo_pod = pod_spec("mongo", mongo_container) mongo_pod["volumes"] = [ {"name": "data", "persistentVolumeClaim": {"claimName": c["mongoPvcName"]}}, {"name": "mongo-init", "configMap": {"name": prefix + "-mongo-init"}}, ] # The official Mongo entrypoint can initialize as its pre-created uid 999. # Kubernetes fsGroup makes a fresh PVC writable without root chown/gosu. mongo_pod["securityContext"] = { "runAsNonRoot": True, "runAsUser": 999, "runAsGroup": 999, "fsGroup": 999, "seccompProfile": {"type": "RuntimeDefault"}, } items.append(obj("apps/v1", "Deployment", mongo, { "replicas": 1, "strategy": {"type": "Recreate"}, "selector": {"matchLabels": {"app": mongo}}, "template": {"metadata": {"labels": {**labels, "app": mongo}}, "spec": mongo_pod}, })) app_mongo_env = [env("MONGO_DB", value=db), env("MONGO_URI", key="MONGO_URI")] expected_uri_suffix = f"@{mongo}.{ns}.svc.cluster.local:27017/{db}?authSource={db}" guard = { "name": "validate-mongo-target", "image": c["image"], "imagePullPolicy": "IfNotPresent", "command": ["/bin/sh", "-ec", """ case "$MONGO_URI" in mongodb://*"$EXPECTED_URI_SUFFIX") ;; *) echo 'Mongo target must be the isolated test database' >&2; exit 1;; esac uri_body=${MONGO_URI#mongodb://} userinfo=${uri_body%%@*} case "$userinfo" in *:*) ;; *) exit 1;; esac case "${uri_body#*@}" in *'@'*) exit 1;; esac """], "env": [env("MONGO_URI", key="MONGO_URI"), env("EXPECTED_URI_SUFFIX", value=expected_uri_suffix)], "resources": {"requests": {"cpu": "10m", "memory": "16Mi"}, "limits": {"cpu": "100m", "memory": "64Mi"}}, "securityContext": {"allowPrivilegeEscalation": False, "capabilities": {"drop": ["ALL"]}}, } seed_gate = { "name": "wait-for-seed", "image": c["mongoImage"], "imagePullPolicy": "IfNotPresent", "command": ["/bin/sh", "-ec", """ i=0 while [ "$i" -lt 120 ]; do if mongosh "$MONGO_URI" --quiet --eval ' const ready = db.getCollection("_internalTestSeed").findOne({ _id: "environment", kind: "droboticflow-internal-test-lane", batchId: process.env.EXPECTED_BATCH, state: 'complete' }); quit(ready ? 0 : 1); ' >/dev/null 2>&1; then exit 0; fi i=$((i + 1)) sleep 5 done echo 'Internal test seed is not complete' >&2 exit 1 """], "env": [env("MONGO_URI", key="MONGO_URI"), env("EXPECTED_BATCH", value=c["batchId"])], "resources": {"requests": {"cpu": "10m", "memory": "32Mi"}, "limits": {"cpu": "100m", "memory": "128Mi"}}, "securityContext": {"allowPrivilegeEscalation": False, "capabilities": {"drop": ["ALL"]}}, } api_container = { "name": "api", "image": c["image"], "imagePullPolicy": "IfNotPresent", "ports": [{"name": "http", "containerPort": 3001}], "env": app_mongo_env + [ env("PORT", value="3001"), env("DIST_DIR", value="/app/dist"), env("WORKSPACE_MOUNT_PATH", value="/workspace"), env("ANNOTATION_PROCESSOR_MODE", value="external"), env("DROBOTICFLOW_REQUIRE_SESSION_AUTH", value="true"), env("DROBOTICFLOW_SESSION_COOKIE_SECURE", value="true"), env("DROBOTICFLOW_OBJECT_SYNC_ENABLED", value="false"), env("K8S_NAMESPACE", value=ns), env("WORKSPACE_PVC_NAME", value=c["workspacePvcName"]), env("DROBOTICFLOW_BUILD_COMMIT", value=c["buildCommit"]), env("DROBOTICFLOW_API_TOKEN", key="DROBOTICFLOW_API_TOKEN"), ], "volumeMounts": [{"name": "workspace", "mountPath": "/workspace"}], "resources": c["resources"]["api"], "securityContext": {"allowPrivilegeEscalation": False, "capabilities": {"drop": ["ALL"]}}, "readinessProbe": {"httpGet": {"path": "/api/ready", "port": "http"}, "periodSeconds": 10}, } items.append(deployment("api", api_container, workspace=True, init=[guard, seed_gate])) processor_container = { "name": "processor", "image": c["image"], "imagePullPolicy": "IfNotPresent", "command": ["/usr/local/bin/droboticflow-api"], "ports": [{"name": "health", "containerPort": 3003}], "env": app_mongo_env + [env("ANNOTATION_PROCESSOR_MODE", value="processor"), env("ANNOTATION_PROCESSOR_CONCURRENCY", value="1"), env("ANNOTATION_INDEX_BACKFILL", value="0"), env("WORKSPACE_MOUNT_PATH", value="/workspace")], "volumeMounts": [{"name": "workspace", "mountPath": "/workspace"}], "resources": c["resources"]["processor"], "securityContext": {"allowPrivilegeEscalation": False, "capabilities": {"drop": ["ALL"]}}, "readinessProbe": {"httpGet": {"path": "/ready", "port": "health"}, "periodSeconds": 10}, } items.append(deployment("processor", processor_container, workspace=True, init=[guard, seed_gate])) items.append(obj("v1", "Service", prefix + "-api", { "type": "ClusterIP", "selector": {"app": prefix + "-api"}, "ports": [{"name": "http", "port": 80, "targetPort": 3001}], })) ingress = obj("networking.k8s.io/v1", "Ingress", prefix + "-api", { "tls": [{"hosts": [c["hostname"]], "secretName": c["tlsSecretName"]}], "rules": [{"host": c["hostname"], "http": {"paths": [{"path": "/", "pathType": "Prefix", "backend": {"service": {"name": prefix + "-api", "port": {"number": 80}}}}]}}], }) ingress["metadata"]["annotations"] = {"nginx.ingress.kubernetes.io/ssl-redirect": "true"} if "ingressClassName" in c: ingress["spec"]["ingressClassName"] = c["ingressClassName"] items.append(ingress) items.append(obj("v1", "ResourceQuota", "internal-test-quota", {"hard": { "pods": "3", "persistentvolumeclaims": "8", "requests.storage": f"{4 * (c['workspaceGi'] + c['mongoGi'])}Gi", "requests.cpu": _millicores(sum(_quantity(c["resources"][component]["requests"]["cpu"], "cpu", cpu=True) for component in ("api", "processor", "mongo"))), "limits.cpu": _millicores(sum(_quantity(c["resources"][component]["limits"]["cpu"], "cpu", cpu=True) for component in ("api", "processor", "mongo"))), "requests.memory": f"{sum(_quantity(c['resources'][component]['requests']['memory'], 'memory', cpu=False) for component in ('api', 'processor', 'mongo'))}Mi", "limits.memory": f"{sum(_quantity(c['resources'][component]['limits']['memory'], 'memory', cpu=False) for component in ('api', 'processor', 'mongo'))}Mi", }})) items.append(obj("networking.k8s.io/v1", "NetworkPolicy", prefix + "-default-deny", { "podSelector": {}, "policyTypes": ["Ingress", "Egress"], })) items.append(obj("networking.k8s.io/v1", "NetworkPolicy", prefix + "-allow-mongo", { "podSelector": {"matchLabels": {"app": mongo}}, "policyTypes": ["Ingress"], "ingress": [{"from": [{"podSelector": {"matchLabels": {"app": prefix + "-api"}}}, {"podSelector": {"matchLabels": {"app": prefix + "-processor"}}}, {"podSelector": {"matchLabels": {"app": prefix + "-initializer"}}}], "ports": [{"protocol": "TCP", "port": 27017}]}], })) items.append(obj("networking.k8s.io/v1", "NetworkPolicy", prefix + "-allow-app-egress", { "podSelector": {"matchExpressions": [{"key": "app", "operator": "In", "values": [prefix + "-api", prefix + "-processor", prefix + "-initializer"]}]}, "policyTypes": ["Egress"], "egress": [ {"to": [{"podSelector": {"matchLabels": {"app": mongo}}}], "ports": [{"protocol": "TCP", "port": 27017}]}, {"to": [{"namespaceSelector": {"matchLabels": {"kubernetes.io/metadata.name": "kube-system"}}}], "ports": [{"protocol": "UDP", "port": 53}, {"protocol": "TCP", "port": 53}]}, ], })) items.append(obj("networking.k8s.io/v1", "NetworkPolicy", prefix + "-allow-ingress", { "podSelector": {"matchLabels": {"app": prefix + "-api"}}, "policyTypes": ["Ingress"], "ingress": [{"from": [{"namespaceSelector": {"matchLabels": {"kubernetes.io/metadata.name": c["ingressNamespace"]}}}], "ports": [{"protocol": "TCP", "port": 3001}]}], })) # Apply policies and quotas before the first workload can become runnable. priority = { "Namespace": 0, "ResourceQuota": 1, "NetworkPolicy": 2, "ServiceAccount": 3, "ConfigMap": 4, "PersistentVolumeClaim": 5, "Service": 6, "Deployment": 7, "Ingress": 8, } items.sort(key=lambda item: priority[item["kind"]]) return {"apiVersion": "v1", "kind": "List", "items": items} def render_initializer(config: dict) -> dict: """Render a temporary pod for an approved seed operation. The pod is deliberately absent from render_environment. An operator creates it only after review, then removes it before enabling the API and processor. The application image supplies the same Debian runtime as the seed executable, but this manifest does not embed assets or credentials. """ c = validate_config(config) prefix = c["resourcePrefix"] suffix = f"@{c['mongoServiceName']}.{c['namespace']}.svc.cluster.local:27017/{c['databaseName']}?authSource={c['databaseName']}" return { "apiVersion": "v1", "kind": "Pod", "metadata": { "name": prefix + "-initializer", "namespace": c["namespace"], "labels": {"app.kubernetes.io/part-of": "droboticflow-internal-test", "internal-test/batch": c["batchId"], "app": prefix + "-initializer"}, "annotations": {"internal-test/purpose": "temporary-approved-seed"}, }, "spec": { "serviceAccountName": prefix + "-initializer", "automountServiceAccountToken": False, "restartPolicy": "Never", "activeDeadlineSeconds": 28800, "imagePullSecrets": [{"name": c["imagePullSecretName"]}], "securityContext": {"runAsNonRoot": True, "runAsUser": 10001, "runAsGroup": 10001, "fsGroup": 10001, "seccompProfile": {"type": "RuntimeDefault"}}, "containers": [{ "name": "initializer", "image": c["image"], "imagePullPolicy": "IfNotPresent", "command": ["/bin/sh", "-ec", """ case "$MONGO_URI" in mongodb://*"$EXPECTED_URI_SUFFIX") ;; *) echo 'Mongo target must be the isolated test database' >&2; exit 1;; esac uri_body=${MONGO_URI#mongodb://} case "${uri_body#*@}" in *'@'*) exit 1;; esac sleep 28800 """], "env": [ {"name": "MONGO_URI", "valueFrom": {"secretKeyRef": {"name": c["credentialsSecretName"], "key": "MONGO_URI"}}}, {"name": "EXPECTED_URI_SUFFIX", "value": suffix}, {"name": "MONGO_DB", "value": c["databaseName"]}, {"name": "WORKSPACE_MOUNT_PATH", "value": "/workspace"}, {"name": "INTERNAL_TEST_BATCH_ID", "value": c["batchId"]}, ], "resources": c["resources"]["api"], "securityContext": {"allowPrivilegeEscalation": False, "capabilities": {"drop": ["ALL"]}}, "volumeMounts": [{"name": "workspace", "mountPath": "/workspace"}, {"name": "scratch", "mountPath": "/tmp"}], }], "volumes": [ {"name": "workspace", "persistentVolumeClaim": {"claimName": c["workspacePvcName"]}}, {"name": "scratch", "emptyDir": {"sizeLimit": "2Gi"}}, ], }, } def _millicores(value: int) -> str: return f"{value}m"