droboticflow/scripts/operator_release_manifest.py

188 lines
6.3 KiB
Python

#!/usr/bin/env python3
from __future__ import annotations
import hashlib
import json
import os
import pathlib
import re
import subprocess
from typing import Any
ROOT = pathlib.Path(__file__).resolve().parents[1]
CATALOG_PATH = ROOT / "internal" / "api" / "builtin_operators_catalog.json"
OPERATOR_REPO_ROOT = ROOT / "operator-repos" / "builtin"
DEFAULT_RELEASE_ENV = "poc"
RELEASE_SCHEMA_VERSION = "droboticflow.operator.release/v1"
DIGEST_RE = re.compile(r"^.+@sha256:[a-f0-9]{64}$")
def load_json(path: pathlib.Path) -> Any:
return json.loads(path.read_text(encoding="utf-8"))
def dump_json(payload: Any) -> str:
return json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True) + "\n"
def operator_slug(operator_id: str) -> str:
return operator_id.removeprefix("operator-builtin-").replace("-", "_")
def release_env() -> str:
value = os.getenv("OPERATOR_RELEASE_ENV", "").strip() or os.getenv("DEPLOY_ENV", "").strip()
if value == "dev":
return DEFAULT_RELEASE_ENV
return value or DEFAULT_RELEASE_ENV
def release_path(slug: str) -> pathlib.Path:
return OPERATOR_REPO_ROOT / slug / "release.json"
def git_commit() -> str:
try:
return (
subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=ROOT, text=True)
.strip()
)
except Exception:
return ""
def image_digest(image_id: str) -> str:
if "@sha256:" not in image_id:
return ""
return "sha256:" + image_id.rsplit("@sha256:", 1)[1]
def image_registry(image: str) -> str:
return image.split("/", 1)[0] if "/" in image else ""
def image_tag(image: str) -> str:
tail = image.rsplit("/", 1)[-1]
if ":" not in tail:
return ""
return tail.rsplit(":", 1)[1]
def release_source_files(operator_dir: pathlib.Path) -> list[pathlib.Path]:
ignored = {"release.json", "repository.json"}
return sorted(
path
for path in operator_dir.rglob("*")
if path.is_file() and path.name not in ignored
)
def source_tree_sha256(slug: str) -> str:
operator_dir = OPERATOR_REPO_ROOT / slug
digest = hashlib.sha256()
for path in release_source_files(operator_dir):
relative = path.relative_to(operator_dir).as_posix()
digest.update(relative.encode("utf-8"))
digest.update(b"\0")
digest.update(path.read_bytes())
digest.update(b"\0")
return digest.hexdigest()
def load_release(slug: str) -> dict[str, Any]:
path = release_path(slug)
if not path.exists():
raise RuntimeError(f"operator_release_manifest_missing: missing {path.relative_to(ROOT)}")
release = load_json(path)
validate_release(slug, release)
return release
def release_environment(release: dict[str, Any], env: str | None = None) -> dict[str, Any]:
selected_env = env or release_env()
releases = release.get("environmentReleases")
if isinstance(releases, dict) and isinstance(releases.get(selected_env), dict):
env_release = dict(releases[selected_env])
return {
**release,
**env_release,
"environment": selected_env,
}
return {**release, "environment": selected_env}
def release_image_reference(slug: str, env: str | None = None) -> tuple[str, str]:
release = release_environment(load_release(slug), env)
image = str(release.get("image") or "").strip()
image_id = str(release.get("imageId") or "").strip()
if not image or not DIGEST_RE.match(image_id):
raise RuntimeError(
f"operator_release_digest_drift: {slug} release must contain image and digest-pinned imageId"
)
return image, image_id
def validate_release(slug: str, release: dict[str, Any]) -> None:
path_label = release_path(slug).relative_to(ROOT)
if release.get("schemaVersion") != RELEASE_SCHEMA_VERSION:
raise RuntimeError(f"operator_release_manifest_missing: {path_label} schemaVersion must be {RELEASE_SCHEMA_VERSION}")
if release.get("slug") != slug:
raise RuntimeError(f"operator_release_digest_drift: {path_label} slug must be {slug}")
image = str(release.get("image") or "").strip()
image_id = str(release.get("imageId") or "").strip()
digest = str(release.get("digest") or "").strip()
if not image:
raise RuntimeError(f"operator_release_manifest_missing: {path_label} image is required")
if not DIGEST_RE.match(image_id):
raise RuntimeError(f"operator_release_digest_drift: {path_label} imageId must be repo@sha256:<64 hex>")
if digest and digest != image_digest(image_id):
raise RuntimeError(f"operator_release_digest_drift: {path_label} digest must match imageId")
source_tree = str(release.get("sourceTreeSha256") or "").strip()
if not re.fullmatch(r"[a-f0-9]{64}", source_tree):
raise RuntimeError(f"operator_release_manifest_missing: {path_label} sourceTreeSha256 is required")
current_source_tree = source_tree_sha256(slug)
if source_tree != current_source_tree:
raise RuntimeError(
f"operator_release_digest_drift: {path_label} sourceTreeSha256 {source_tree} does not match current {current_source_tree}"
)
def release_from_catalog_item(item: dict[str, Any], *, env: str | None = None) -> dict[str, Any]:
slug = operator_slug(item["id"])
image = str(item.get("image") or "").strip()
image_id = str(item.get("imageId") or "").strip()
digest = image_digest(image_id)
selected_env = env or release_env()
release = {
"schemaVersion": RELEASE_SCHEMA_VERSION,
"operatorId": item["id"],
"slug": slug,
"sourceCommit": git_commit(),
"sourceTreeSha256": source_tree_sha256(slug),
"image": image,
"imageId": image_id,
"digest": digest,
"registry": image_registry(image),
"tag": image_tag(image),
"builtAt": "",
"kanikoJob": "",
"acceptance": {
"projectId": "",
"workflowId": "",
"runId": "",
"artifactId": "",
"verifiedAt": "",
},
"environmentReleases": {
selected_env: {
"image": image,
"imageId": image_id,
"digest": digest,
"registry": image_registry(image),
"tag": image_tag(image),
}
},
}
return release