340 lines
9.8 KiB
Bash
340 lines
9.8 KiB
Bash
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
|
|
TMP_DIR="$ROOT_DIR/.tmp/ui-e2e"
|
|
LOG_DIR="$TMP_DIR/logs"
|
|
POSTGRES_CONTAINER="crank-e2e-postgres"
|
|
POSTGRES_PORT="${CRANK_E2E_POSTGRES_PORT:-55433}"
|
|
ADMIN_PORT="${CRANK_E2E_ADMIN_PORT:-3301}"
|
|
MCP_PORT="${CRANK_E2E_MCP_PORT:-3302}"
|
|
UI_PORT="${CRANK_E2E_UI_PORT:-3300}"
|
|
STREAM_FIXTURE_PORT="${CRANK_E2E_STREAM_FIXTURE_PORT:-3310}"
|
|
POSTGRES_DB="${CRANK_E2E_POSTGRES_DB:-crank}"
|
|
POSTGRES_USER="${CRANK_E2E_POSTGRES_USER:-crank}"
|
|
POSTGRES_PASSWORD="${CRANK_E2E_POSTGRES_PASSWORD:-crank}"
|
|
POSTGRES_HOST="${CRANK_E2E_POSTGRES_HOST:-127.0.0.1}"
|
|
USE_EXTERNAL_POSTGRES="${CRANK_E2E_USE_EXTERNAL_POSTGRES:-0}"
|
|
ADMIN_EMAIL="${CRANK_E2E_ADMIN_EMAIL:-owner@crank.local}"
|
|
ADMIN_PASSWORD="${CRANK_E2E_ADMIN_PASSWORD:-change-me-admin-password}"
|
|
STARTUP_TIMEOUT_SECONDS="${CRANK_E2E_STARTUP_TIMEOUT_SECONDS:-120}"
|
|
|
|
if [[ ! "$STARTUP_TIMEOUT_SECONDS" =~ ^[1-9][0-9]*$ ]]; then
|
|
echo "CRANK_E2E_STARTUP_TIMEOUT_SECONDS must be a positive integer" >&2
|
|
exit 1
|
|
fi
|
|
|
|
# These variables configure only this orchestration script. The application
|
|
# rejects unknown variables in the owned CRANK_* namespace, so never leak the
|
|
# E2E control plane into production process configuration.
|
|
unset \
|
|
CRANK_E2E_ADMIN_EMAIL \
|
|
CRANK_E2E_ADMIN_PASSWORD \
|
|
CRANK_E2E_ADMIN_PORT \
|
|
CRANK_E2E_MCP_PORT \
|
|
CRANK_E2E_POSTGRES_DB \
|
|
CRANK_E2E_POSTGRES_HOST \
|
|
CRANK_E2E_POSTGRES_PASSWORD \
|
|
CRANK_E2E_POSTGRES_PORT \
|
|
CRANK_E2E_POSTGRES_USER \
|
|
CRANK_E2E_STARTUP_TIMEOUT_SECONDS \
|
|
CRANK_E2E_STREAM_FIXTURE_PORT \
|
|
CRANK_E2E_UI_PORT \
|
|
CRANK_E2E_USE_EXTERNAL_POSTGRES
|
|
|
|
if [[ -f "$HOME/.cargo/env" ]]; then
|
|
. "$HOME/.cargo/env"
|
|
fi
|
|
|
|
PYTHON_BIN="${PYTHON_BIN:-}"
|
|
if [[ -z "$PYTHON_BIN" ]]; then
|
|
if command -v python3 >/dev/null 2>&1; then
|
|
PYTHON_BIN="python3"
|
|
else
|
|
PYTHON_BIN="python"
|
|
fi
|
|
fi
|
|
|
|
mkdir -p "$LOG_DIR"
|
|
find "$LOG_DIR" -maxdepth 1 -type f -name '*.log' -delete
|
|
|
|
(
|
|
cd "$ROOT_DIR/apps/ui"
|
|
npm run build >"$LOG_DIR/ui-build.log" 2>&1
|
|
)
|
|
|
|
kill_port_processes() {
|
|
local port="$1"
|
|
if command -v lsof >/dev/null 2>&1; then
|
|
lsof -ti "tcp:$port" | xargs -r kill >/dev/null 2>&1 || true
|
|
fi
|
|
}
|
|
|
|
cleanup() {
|
|
set +e
|
|
if [[ -f "$TMP_DIR/admin-api.pid" ]]; then
|
|
kill "$(cat "$TMP_DIR/admin-api.pid")" >/dev/null 2>&1 || true
|
|
rm -f "$TMP_DIR/admin-api.pid"
|
|
fi
|
|
if [[ -f "$TMP_DIR/mcp-server.pid" ]]; then
|
|
kill "$(cat "$TMP_DIR/mcp-server.pid")" >/dev/null 2>&1 || true
|
|
rm -f "$TMP_DIR/mcp-server.pid"
|
|
fi
|
|
if [[ -f "$TMP_DIR/ui-server.pid" ]]; then
|
|
kill "$(cat "$TMP_DIR/ui-server.pid")" >/dev/null 2>&1 || true
|
|
rm -f "$TMP_DIR/ui-server.pid"
|
|
fi
|
|
if [[ -f "$TMP_DIR/http-fixture.pid" ]]; then
|
|
kill "$(cat "$TMP_DIR/http-fixture.pid")" >/dev/null 2>&1 || true
|
|
rm -f "$TMP_DIR/http-fixture.pid"
|
|
fi
|
|
if [[ "$USE_EXTERNAL_POSTGRES" != "1" ]]; then
|
|
docker rm -f "$POSTGRES_CONTAINER" >/dev/null 2>&1 || true
|
|
fi
|
|
kill_port_processes "$UI_PORT"
|
|
kill_port_processes "$ADMIN_PORT"
|
|
kill_port_processes "$MCP_PORT"
|
|
kill_port_processes "$STREAM_FIXTURE_PORT"
|
|
}
|
|
|
|
trap cleanup EXIT
|
|
trap 'exit 130' INT TERM
|
|
|
|
cleanup
|
|
|
|
show_startup_log() {
|
|
local log_file="$1"
|
|
if [[ -f "$log_file" ]]; then
|
|
echo "---- $log_file ----" >&2
|
|
tail -n 120 "$log_file" >&2
|
|
fi
|
|
}
|
|
|
|
wait_for_port() {
|
|
local label="$1"
|
|
local host="$2"
|
|
local port="$3"
|
|
local deadline=$((SECONDS + STARTUP_TIMEOUT_SECONDS))
|
|
|
|
echo "Waiting for $label on $host:$port"
|
|
while true; do
|
|
if "$PYTHON_BIN" - "$host" "$port" <<'PY'
|
|
import socket, sys
|
|
sock = socket.socket()
|
|
sock.settimeout(0.5)
|
|
try:
|
|
sock.connect((sys.argv[1], int(sys.argv[2])))
|
|
except OSError:
|
|
sys.exit(1)
|
|
finally:
|
|
sock.close()
|
|
PY
|
|
then
|
|
return 0
|
|
fi
|
|
if (( SECONDS >= deadline )); then
|
|
echo "Timed out waiting for $label on $host:$port after ${STARTUP_TIMEOUT_SECONDS}s" >&2
|
|
return 1
|
|
fi
|
|
sleep 1
|
|
done
|
|
}
|
|
|
|
wait_for_http() {
|
|
local label="$1"
|
|
local url="$2"
|
|
local pid_file="$3"
|
|
local log_file="$4"
|
|
local deadline=$((SECONDS + STARTUP_TIMEOUT_SECONDS))
|
|
|
|
echo "Waiting for $label at $url"
|
|
while true; do
|
|
if "$PYTHON_BIN" - "$url" <<'PY'
|
|
import sys, urllib.request
|
|
try:
|
|
with urllib.request.urlopen(sys.argv[1], timeout=0.5) as response:
|
|
sys.exit(0 if 200 <= response.status < 400 else 1)
|
|
except Exception:
|
|
sys.exit(1)
|
|
PY
|
|
then
|
|
return 0
|
|
fi
|
|
|
|
local pid=""
|
|
if [[ -f "$pid_file" ]]; then
|
|
pid="$(cat "$pid_file")"
|
|
fi
|
|
if [[ -z "$pid" ]] || ! kill -0 "$pid" >/dev/null 2>&1; then
|
|
echo "$label exited before becoming ready at $url" >&2
|
|
show_startup_log "$log_file"
|
|
return 1
|
|
fi
|
|
if (( SECONDS >= deadline )); then
|
|
echo "Timed out waiting for $label at $url after ${STARTUP_TIMEOUT_SECONDS}s" >&2
|
|
show_startup_log "$log_file"
|
|
return 1
|
|
fi
|
|
sleep 1
|
|
done
|
|
}
|
|
|
|
wait_for_postgres_container() {
|
|
local deadline=$((SECONDS + STARTUP_TIMEOUT_SECONDS))
|
|
echo "Waiting for PostgreSQL container $POSTGRES_CONTAINER"
|
|
while ! docker exec "$POSTGRES_CONTAINER" pg_isready -U "$POSTGRES_USER" -d "$POSTGRES_DB" >/dev/null 2>&1; do
|
|
if ! docker inspect "$POSTGRES_CONTAINER" >/dev/null 2>&1; then
|
|
echo "PostgreSQL container $POSTGRES_CONTAINER exited before becoming ready" >&2
|
|
return 1
|
|
fi
|
|
if (( SECONDS >= deadline )); then
|
|
echo "Timed out waiting for PostgreSQL container after ${STARTUP_TIMEOUT_SECONDS}s" >&2
|
|
docker logs "$POSTGRES_CONTAINER" >&2 || true
|
|
return 1
|
|
fi
|
|
sleep 1
|
|
done
|
|
}
|
|
|
|
if [[ "$USE_EXTERNAL_POSTGRES" = "1" ]]; then
|
|
wait_for_port "PostgreSQL" "$POSTGRES_HOST" "$POSTGRES_PORT" || exit 1
|
|
else
|
|
docker run -d --rm \
|
|
--name "$POSTGRES_CONTAINER" \
|
|
-e POSTGRES_DB="$POSTGRES_DB" \
|
|
-e POSTGRES_USER="$POSTGRES_USER" \
|
|
-e POSTGRES_PASSWORD="$POSTGRES_PASSWORD" \
|
|
-p "$POSTGRES_PORT:5432" \
|
|
postgres:16-alpine >/dev/null
|
|
|
|
wait_for_postgres_container || exit 1
|
|
fi
|
|
|
|
export POSTGRES_HOST
|
|
export POSTGRES_PORT="$POSTGRES_PORT"
|
|
export POSTGRES_DB="$POSTGRES_DB"
|
|
export POSTGRES_USER="$POSTGRES_USER"
|
|
export POSTGRES_PASSWORD="$POSTGRES_PASSWORD"
|
|
export DATABASE_URL="postgres://$POSTGRES_USER:$POSTGRES_PASSWORD@$POSTGRES_HOST:$POSTGRES_PORT/$POSTGRES_DB"
|
|
export SQLX_OFFLINE="true"
|
|
export CRANK_STORAGE_ROOT="$TMP_DIR/storage"
|
|
export CRANK_ADMIN_BIND="0.0.0.0:$ADMIN_PORT"
|
|
export CRANK_MCP_BIND="0.0.0.0:$MCP_PORT"
|
|
export CRANK_MCP_REFRESH_MS="1000"
|
|
export CRANK_OUTBOUND_ALLOWED_HOSTS="127.0.0.1"
|
|
export CRANK_LOG_LEVEL="info"
|
|
export CRANK_SESSION_SECRET="e2e-session-secret"
|
|
export CRANK_PASSWORD_PEPPER="e2e-password-pepper"
|
|
export CRANK_MASTER_KEY="0000000000000000000000000000000000000000000000000000000000000000"
|
|
export CRANK_SESSION_TTL_HOURS="24"
|
|
export CRANK_BOOTSTRAP_ADMIN_EMAIL="$ADMIN_EMAIL"
|
|
export CRANK_BOOTSTRAP_ADMIN_DISPLAY_NAME="Crank E2E"
|
|
export CRANK_BASE_URL="http://127.0.0.1:$UI_PORT"
|
|
mkdir -p -m 700 "$CRANK_STORAGE_ROOT"
|
|
chmod 700 "$CRANK_STORAGE_ROOT"
|
|
|
|
(
|
|
cd "$ROOT_DIR/apps/ui"
|
|
exec node scripts/playwright-http-fixture.js >"$LOG_DIR/http-fixture.log" 2>&1
|
|
) &
|
|
echo $! > "$TMP_DIR/http-fixture.pid"
|
|
|
|
wait_for_http \
|
|
"Playwright HTTP fixture" \
|
|
"http://127.0.0.1:$STREAM_FIXTURE_PORT/health" \
|
|
"$TMP_DIR/http-fixture.pid" \
|
|
"$LOG_DIR/http-fixture.log" || exit 1
|
|
|
|
if ! (
|
|
cd "$ROOT_DIR"
|
|
cargo run -p admin-api --bin crank-migrate -- apply >"$LOG_DIR/migrate.log" 2>&1
|
|
); then
|
|
echo "Failed to apply E2E database migrations" >&2
|
|
show_startup_log "$LOG_DIR/migrate.log"
|
|
exit 1
|
|
fi
|
|
|
|
if ! (
|
|
cd "$ROOT_DIR"
|
|
cargo run -p admin-api --bin crank-migrate -- admin-auth bootstrap-create \
|
|
--email "$ADMIN_EMAIL" \
|
|
--display-name "Crank E2E" \
|
|
>"$LOG_DIR/bootstrap-create.log" 2>&1
|
|
); then
|
|
echo "Failed to create the E2E bootstrap contract" >&2
|
|
show_startup_log "$LOG_DIR/bootstrap-create.log"
|
|
exit 1
|
|
fi
|
|
BOOTSTRAP_JSON="$(tail -n 1 "$LOG_DIR/bootstrap-create.log")"
|
|
if ! BOOTSTRAP_TOKEN="$("$PYTHON_BIN" - <<'PY' "$BOOTSTRAP_JSON"
|
|
import json, sys
|
|
print(json.loads(sys.argv[1])["bootstrap_token"])
|
|
PY
|
|
)"; then
|
|
echo "Failed to parse the E2E bootstrap token" >&2
|
|
show_startup_log "$LOG_DIR/bootstrap-create.log"
|
|
exit 1
|
|
fi
|
|
printf '%s' "$BOOTSTRAP_TOKEN" >"$TMP_DIR/bootstrap-token.txt"
|
|
printf '%s' "$ADMIN_PASSWORD" >"$TMP_DIR/admin-password.txt"
|
|
printf '%s' "$CRANK_PASSWORD_PEPPER" >"$TMP_DIR/password-pepper.txt"
|
|
|
|
if ! (
|
|
cd "$ROOT_DIR"
|
|
cargo run -p admin-api --bin crank-migrate -- admin-auth bootstrap-complete \
|
|
--token-file "$TMP_DIR/bootstrap-token.txt" \
|
|
--password-file "$TMP_DIR/admin-password.txt" \
|
|
--password-pepper-file "$TMP_DIR/password-pepper.txt" \
|
|
>"$LOG_DIR/bootstrap-complete.log" 2>&1
|
|
); then
|
|
echo "Failed to complete the E2E admin bootstrap" >&2
|
|
show_startup_log "$LOG_DIR/bootstrap-complete.log"
|
|
exit 1
|
|
fi
|
|
|
|
(
|
|
cd "$ROOT_DIR"
|
|
exec env -u CRANK_MCP_BIND -u CRANK_MCP_REFRESH_MS CRANK_DEMO_SEED=true \
|
|
cargo run -p admin-api --bin admin-api >>"$LOG_DIR/admin-api.log" 2>&1
|
|
) &
|
|
echo $! > "$TMP_DIR/admin-api.pid"
|
|
|
|
wait_for_http \
|
|
"admin-api" \
|
|
"http://127.0.0.1:$ADMIN_PORT/health" \
|
|
"$TMP_DIR/admin-api.pid" \
|
|
"$LOG_DIR/admin-api.log" || exit 1
|
|
|
|
(
|
|
cd "$ROOT_DIR"
|
|
exec env -u CRANK_ADMIN_BIND -u CRANK_STORAGE_ROOT -u CRANK_SESSION_SECRET \
|
|
-u CRANK_PASSWORD_PEPPER -u CRANK_SESSION_TTL_HOURS \
|
|
-u CRANK_BOOTSTRAP_ADMIN_EMAIL -u CRANK_BOOTSTRAP_ADMIN_DISPLAY_NAME -u CRANK_DEMO_SEED \
|
|
cargo run -p mcp-server >"$LOG_DIR/mcp-server.log" 2>&1
|
|
) &
|
|
echo $! > "$TMP_DIR/mcp-server.pid"
|
|
|
|
wait_for_http \
|
|
"mcp-server" \
|
|
"http://127.0.0.1:$MCP_PORT/health" \
|
|
"$TMP_DIR/mcp-server.pid" \
|
|
"$LOG_DIR/mcp-server.log" || exit 1
|
|
|
|
(
|
|
cd "$ROOT_DIR/apps/ui"
|
|
exec node scripts/playwright-ui-server.js >"$LOG_DIR/ui-server.log" 2>&1
|
|
) &
|
|
echo $! > "$TMP_DIR/ui-server.pid"
|
|
|
|
wait_for_http \
|
|
"Playwright UI server" \
|
|
"http://127.0.0.1:$UI_PORT/login" \
|
|
"$TMP_DIR/ui-server.pid" \
|
|
"$LOG_DIR/ui-server.log" || exit 1
|
|
|
|
echo "Crank UI e2e stack is ready on http://127.0.0.1:$UI_PORT"
|
|
|
|
while true; do
|
|
sleep 1
|
|
done
|