263 lines
8.6 KiB
Bash
263 lines
8.6 KiB
Bash
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
META_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
|
|
ROOT="${GOVOPLAN_CORE_ROOT:-$META_ROOT/../govoplan-core}"
|
|
ROOT="$(cd "$ROOT" && pwd)"
|
|
VENV_ROOT="${GOVOPLAN_VENV_ROOT:-$META_ROOT/.venv}"
|
|
PYTHON="${PYTHON:-$VENV_ROOT/bin/python}"
|
|
NPM="${NPM:-/home/zemion/.nvm/versions/node/v22.22.3/bin/npm}"
|
|
NODE_BIN="$(dirname "$NPM")"
|
|
WEBUI_BIN="$ROOT/webui/node_modules/.bin"
|
|
NPM_USERCONFIG="$(mktemp "${TMPDIR:-/tmp}/govoplan-npmrc.XXXXXXXX")"
|
|
WORK_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/govoplan-release-integration.XXXXXXXX")"
|
|
|
|
trap 'rm -rf "$WORK_ROOT"; rm -f "$NPM_USERCONFIG"' EXIT
|
|
|
|
if [[ ! -x "$PYTHON" ]]; then
|
|
PYTHON=python
|
|
fi
|
|
if [[ ! -x "$NPM" ]]; then
|
|
NPM=npm
|
|
NODE_BIN="$(dirname "$(command -v "$NPM")")"
|
|
fi
|
|
|
|
cd "$ROOT"
|
|
|
|
RELEASE_VERSION="$("$PYTHON" - <<'PY'
|
|
from pathlib import Path
|
|
import tomllib
|
|
|
|
with (Path.cwd() / "pyproject.toml").open("rb") as handle:
|
|
print(tomllib.load(handle)["project"]["version"])
|
|
PY
|
|
)"
|
|
|
|
export RELEASE_VERSION
|
|
export META_ROOT
|
|
export GOVOPLAN_CORE_SOURCE_ROOT="$ROOT"
|
|
export GOVOPLAN_MIGRATION_TRACK=release
|
|
export PATH="$WEBUI_BIN:$NODE_BIN:$PATH"
|
|
export NPM_CONFIG_USERCONFIG="$NPM_USERCONFIG"
|
|
unset npm_config_tmp NPM_CONFIG_TMP
|
|
|
|
run_step() {
|
|
echo
|
|
echo "==> $*"
|
|
}
|
|
|
|
retry() {
|
|
local attempt status
|
|
for attempt in 1 2 3; do
|
|
if "$@"; then
|
|
return 0
|
|
fi
|
|
status=$?
|
|
if [[ "$attempt" == 3 ]]; then
|
|
return "$status"
|
|
fi
|
|
sleep $((attempt * 10))
|
|
done
|
|
}
|
|
|
|
install_cloned_webui_dependencies() {
|
|
local webui_dir="$1"
|
|
if [[ ! -f "$webui_dir/package.json" ]]; then
|
|
echo "No package.json found under $webui_dir; skipping WebUI dependency install."
|
|
return 0
|
|
fi
|
|
(
|
|
cd "$webui_dir"
|
|
retry "$NPM" install --prefer-online --include=dev --no-save
|
|
)
|
|
}
|
|
|
|
release_tag_for_package() {
|
|
local package_name="$1"
|
|
"$PYTHON" - "$META_ROOT/requirements-release.txt" "$package_name" <<'PY'
|
|
from __future__ import annotations
|
|
|
|
from pathlib import Path
|
|
import re
|
|
import sys
|
|
|
|
|
|
requirements_path = Path(sys.argv[1])
|
|
package_name = sys.argv[2]
|
|
pattern = re.compile(
|
|
rf"^{re.escape(package_name)}\s+@\s+git\+ssh://.+?\.git@(v[0-9]+\.[0-9]+\.[0-9]+)$"
|
|
)
|
|
for line in requirements_path.read_text(encoding="utf-8").splitlines():
|
|
match = pattern.match(line.strip())
|
|
if match:
|
|
print(match.group(1))
|
|
raise SystemExit(0)
|
|
raise SystemExit(f"No immutable release reference found for {package_name}")
|
|
PY
|
|
}
|
|
|
|
run_step "Validate release refs and installed package metadata"
|
|
"$PYTHON" "$META_ROOT/tools/checks/check-version-alignment.py" --release-composition
|
|
"$PYTHON" "$META_ROOT/tools/checks/check-contracts.py" --no-impact
|
|
"$PYTHON" - <<'PY'
|
|
from __future__ import annotations
|
|
|
|
import importlib.metadata as metadata
|
|
import json
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
root = Path.cwd()
|
|
release_requirements = Path(os.environ["META_ROOT"]) / "requirements-release.txt"
|
|
release_webui = root / "webui" / "package.release.json"
|
|
expected_version = os.environ["RELEASE_VERSION"]
|
|
errors: list[str] = []
|
|
|
|
python_requirements: list[tuple[str, str, str]] = []
|
|
for line in release_requirements.read_text(encoding="utf-8").splitlines():
|
|
match = re.match(r"^(govoplan-[a-z0-9-]+)\s+@\s+git\+ssh://(.+?\.git)@(v[0-9]+\.[0-9]+\.[0-9]+)$", line.strip())
|
|
if match:
|
|
python_requirements.append((match.group(1), f"ssh://{match.group(2)}", match.group(3)))
|
|
|
|
if not python_requirements:
|
|
errors.append("No GovOPlaN git+ssh release requirements found.")
|
|
|
|
for package_name, repo_url, tag in python_requirements:
|
|
version = metadata.version(package_name)
|
|
if version != tag.removeprefix("v"):
|
|
errors.append(f"{package_name} installed version {version!r} does not match {tag!r}.")
|
|
result = subprocess.run(
|
|
["git", "ls-remote", "--tags", repo_url, f"refs/tags/{tag}", f"refs/tags/{tag}^{{}}"],
|
|
text=True,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
timeout=45,
|
|
check=False,
|
|
)
|
|
if result.returncode != 0 or f"refs/tags/{tag}" not in result.stdout:
|
|
errors.append(f"{package_name} tag {tag} is not readable from {repo_url}: {result.stderr.strip()}")
|
|
|
|
release_package = json.loads(release_webui.read_text(encoding="utf-8"))
|
|
if release_package.get("version") != expected_version:
|
|
errors.append(f"Core release WebUI version is {release_package.get('version')!r}, expected {expected_version!r}.")
|
|
|
|
webui_dependencies = release_package.get("dependencies", {})
|
|
for package_name, spec in sorted(webui_dependencies.items()):
|
|
if not package_name.startswith("@govoplan/"):
|
|
continue
|
|
tag = spec.rsplit("#", 1)[-1] if "#" in spec else ""
|
|
tag_match = re.fullmatch(r"v([0-9]+\.[0-9]+\.[0-9]+)", tag)
|
|
if tag_match is None:
|
|
errors.append(f"{package_name} release dependency has invalid immutable tag {tag!r}.")
|
|
continue
|
|
dependency_version = tag_match.group(1)
|
|
package_json = root / "webui" / "node_modules" / package_name / "package.json"
|
|
if not package_json.exists():
|
|
errors.append(f"{package_name} is missing from release node_modules.")
|
|
continue
|
|
installed = json.loads(package_json.read_text(encoding="utf-8"))
|
|
if installed.get("version") != dependency_version:
|
|
errors.append(f"{package_name} installed version {installed.get('version')!r}, expected {dependency_version!r} from {tag!r}.")
|
|
|
|
shared_peers = ("lucide-react", "react", "react-dom", "react-router-dom")
|
|
root_peers = release_package.get("peerDependencies", {})
|
|
for package_json in sorted((root / "webui" / "node_modules" / "@govoplan").glob("*/package.json")):
|
|
package = json.loads(package_json.read_text(encoding="utf-8"))
|
|
peers = package.get("peerDependencies", {})
|
|
for name in shared_peers:
|
|
if name in peers and name in root_peers and peers[name] != root_peers[name]:
|
|
errors.append(f"{package.get('name')} peer {name}={peers[name]!r}, expected {root_peers[name]!r}.")
|
|
|
|
if errors:
|
|
print("\n".join(errors), file=sys.stderr)
|
|
raise SystemExit(1)
|
|
|
|
print(f"Release refs and metadata passed for {len(python_requirements)} Python packages and {len(webui_dependencies)} WebUI packages.")
|
|
PY
|
|
|
|
run_step "Validate installed module manifests and registry"
|
|
"$PYTHON" "$META_ROOT/tools/checks/release_integration.py" artifacts \
|
|
--requirements "$META_ROOT/requirements-release.txt"
|
|
|
|
run_step "Generate release dependency provenance"
|
|
"$PYTHON" "$META_ROOT/tools/release/generate-release-sbom.py" \
|
|
--python "$PYTHON" \
|
|
--core-root "$ROOT" \
|
|
--output "$WORK_ROOT/govoplan-sbom.cdx.json"
|
|
|
|
run_step "Run SQLite migration smoke for release modules"
|
|
"$PYTHON" - <<'PY'
|
|
from __future__ import annotations
|
|
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
from govoplan_core.db.migrations import migrate_database
|
|
|
|
enabled_modules = (
|
|
"tenancy",
|
|
"organizations",
|
|
"identity",
|
|
"idm",
|
|
"access",
|
|
"admin",
|
|
"dashboard",
|
|
"policy",
|
|
"audit",
|
|
"campaigns",
|
|
"files",
|
|
"mail",
|
|
"calendar",
|
|
"docs",
|
|
"ops",
|
|
)
|
|
|
|
with tempfile.TemporaryDirectory(prefix="govoplan-release-migration-") as tmp:
|
|
database_url = f"sqlite:///{Path(tmp) / 'release-integration.sqlite3'}"
|
|
result = migrate_database(database_url=database_url, enabled_modules=enabled_modules)
|
|
if not result.current_revision:
|
|
raise SystemExit("Migration smoke did not produce an Alembic revision.")
|
|
print(f"SQLite release migration smoke reached {result.current_revision}.")
|
|
PY
|
|
|
|
run_step "Clone release module test sources"
|
|
for repo in govoplan-mail govoplan-calendar govoplan-campaign; do
|
|
repo_tag="$(release_tag_for_package "$repo")"
|
|
git clone --depth 1 --branch "$repo_tag" "git@git.add-ideas.de:add-ideas/${repo}.git" "$WORK_ROOT/$repo"
|
|
done
|
|
|
|
run_step "Run core backend release tests"
|
|
"$PYTHON" "$META_ROOT/tools/checks/release_integration.py" core-tests \
|
|
--core-root "$ROOT"
|
|
"$PYTHON" "$META_ROOT/tools/checks/check_dependency_boundaries.py"
|
|
|
|
run_step "Run cloned module backend tests"
|
|
for repo in govoplan-mail govoplan-calendar govoplan-campaign; do
|
|
"$PYTHON" "$META_ROOT/tools/checks/release_integration.py" module-tests \
|
|
--module-root "$WORK_ROOT/$repo"
|
|
done
|
|
|
|
run_step "Run core WebUI release tests and build"
|
|
cd "$ROOT/webui"
|
|
"$NPM" run test:mail-components
|
|
"$NPM" run test:module-capabilities
|
|
"$NPM" run test:module-permutations
|
|
"$NPM" run build
|
|
|
|
run_step "Run cloned module WebUI tests"
|
|
install_cloned_webui_dependencies "$WORK_ROOT/govoplan-mail/webui"
|
|
cd "$WORK_ROOT/govoplan-mail/webui"
|
|
"$NPM" run test:mail-ui
|
|
|
|
install_cloned_webui_dependencies "$WORK_ROOT/govoplan-campaign/webui"
|
|
cd "$WORK_ROOT/govoplan-campaign/webui"
|
|
"$NPM" run test:policy-ui
|
|
"$NPM" run test:template-preview
|
|
"$NPM" run test:import-utils
|
|
|
|
echo
|
|
echo "Release integration check passed."
|