droboticflow-new/scripts/poc-strict-full-acceptance.sh

244 lines
7.9 KiB
Bash
Executable File

#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
DEPLOY_ENV="${DEPLOY_ENV:-}"
export DEPLOY_ENV
# shellcheck source=scripts/load-deploy-env.sh
source "$ROOT_DIR/scripts/load-deploy-env.sh"
# shellcheck source=scripts/lib/service-endpoints.sh
source "$ROOT_DIR/scripts/lib/service-endpoints.sh"
K8S_NAMESPACE="${K8S_NAMESPACE:-droboticflow}"
API_PUBLIC_SERVICE_NAME="${API_PUBLIC_SERVICE_NAME:-droboticflow-api-public}"
API_TOKEN_SECRET_NAME="${POC_ACCEPTANCE_API_TOKEN_SECRET_NAME:-droboticflow-auth-secret}"
API_TOKEN_SECRET_KEY="${POC_ACCEPTANCE_API_TOKEN_SECRET_KEY:-DROBOTICFLOW_API_TOKEN}"
POC_OPERATOR_ACCEPTANCE_JOB_NAME="${POC_OPERATOR_ACCEPTANCE_JOB_NAME:-droboticflow-strict-acceptance-$(TZ=Asia/Shanghai date +%Y%m%d%H%M%S)}"
POC_ACCEPTANCE_REQUIRED_EXTERNALS="${POC_ACCEPTANCE_REQUIRED_EXTERNALS:-bos,mongo}"
POC_ACCEPTANCE_IMPORT_RESULT="${POC_ACCEPTANCE_IMPORT_RESULT:-true}"
POC_ACCEPTANCE_IMPORT_API_BASE_URL="${POC_ACCEPTANCE_IMPORT_API_BASE_URL:-${API_BASE_URL:-${BASE_URL:-}}}"
POC_STRICT_READINESS_SCRIPT_PATH="${POC_STRICT_READINESS_SCRIPT_PATH:-$ROOT_DIR/scripts/poc-acceptance-readiness.sh}"
POC_STRICT_OPERATOR_ACCEPTANCE_SCRIPT_PATH="${POC_STRICT_OPERATOR_ACCEPTANCE_SCRIPT_PATH:-$ROOT_DIR/scripts/poc-operator-workflow-acceptance.sh}"
POC_STRICT_PREFLIGHT_RESULT_SCRIPT_PATH="${POC_STRICT_PREFLIGHT_RESULT_SCRIPT_PATH:-$ROOT_DIR/scripts/poc_strict_preflight_result.py}"
POC_STRICT_IMPORT_SCRIPT_PATH="${POC_STRICT_IMPORT_SCRIPT_PATH:-$ROOT_DIR/scripts/import_poc_acceptance_result.py}"
export K8S_NAMESPACE
export POC_OPERATOR_ACCEPTANCE_JOB_NAME
export POC_ACCEPTANCE_REQUIRED_EXTERNALS
export POC_ACCEPTANCE_IMPORT_RESULT
export POC_ACCEPTANCE_IMPORT_API_BASE_URL
export API_PUBLIC_SERVICE_NAME
export POC_OPERATOR_WORKFLOW_REQUIRE_AUDIT_RESOLUTION=true
required_external_enabled() {
local target="$1"
local raw="$POC_ACCEPTANCE_REQUIRED_EXTERNALS"
local item
local items
IFS=',' read -r -a items <<< "$raw"
for item in "${items[@]}"; do
item="$(printf '%s' "$item" | tr '[:upper:]' '[:lower:]')"
item="${item#"${item%%[![:space:]]*}"}"
item="${item%"${item##*[![:space:]]}"}"
if [[ "$item" == "$target" ]]; then
return 0
fi
done
return 1
}
bool_enabled() {
local raw="$1"
local normalized
normalized="$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]')"
[[ "$normalized" == "true" || "$normalized" == "1" || "$normalized" == "yes" || "$normalized" == "on" ]]
}
validate_file() {
local name="$1"
local value="$2"
if [[ ! -f "$value" ]]; then
echo "ERROR: $name not found: $value" >&2
exit 1
fi
}
discover_import_api_base_url() {
if [[ -n "${POC_ACCEPTANCE_IMPORT_API_BASE_URL:-}" || -n "${API_BASE_URL:-}" || -n "${BASE_URL:-}" ]]; then
droboticflow_first_service_url "${POC_ACCEPTANCE_IMPORT_API_BASE_URL:-}" "${API_BASE_URL:-}" "${BASE_URL:-}"
return
fi
kubectl -n "$K8S_NAMESPACE" get svc "$API_PUBLIC_SERVICE_NAME" -o json 2>/dev/null | python3 -c '
import ipaddress
import json
import sys
try:
payload = json.load(sys.stdin)
except json.JSONDecodeError:
raise SystemExit(0)
items = payload.get("status", {}).get("loadBalancer", {}).get("ingress", [])
hosts = [item.get("ip") or item.get("hostname") for item in items if isinstance(item, dict)]
hosts = [item for item in hosts if item]
if not hosts:
raise SystemExit(0)
def is_private(host: str) -> bool:
try:
return ipaddress.ip_address(host).is_private
except ValueError:
return False
for host in hosts:
if not is_private(host):
print(f"http://{host}")
raise SystemExit(0)
print(f"http://{hosts[0]}")
' 2>/dev/null || true
}
load_import_api_token() {
if [[ -n "${DROBOTICFLOW_API_TOKEN:-}" || -n "${DROBOTICFLOW_ACCEPTANCE_EMAIL:-}" ]]; then
return 0
fi
local api_token_secret_json
local token
api_token_secret_json="$(kubectl -n "$K8S_NAMESPACE" get secret "$API_TOKEN_SECRET_NAME" -o json 2>/dev/null || true)"
token="$(
printf "%s" "$api_token_secret_json" | API_TOKEN_SECRET_KEY="$API_TOKEN_SECRET_KEY" python3 -c '
import base64
import json
import os
import sys
try:
payload = json.load(sys.stdin)
except json.JSONDecodeError:
raise SystemExit(0)
data = payload.get("data", {})
if not isinstance(data, dict):
raise SystemExit(0)
raw = data.get(os.environ["API_TOKEN_SECRET_KEY"])
if not isinstance(raw, str) or not raw:
raise SystemExit(0)
try:
print(base64.b64decode(raw, validate=True).decode("utf-8", errors="replace").strip(), end="")
except Exception:
raise SystemExit(0)
'
)"
if [[ -n "$token" ]]; then
export DROBOTICFLOW_API_TOKEN="$token"
fi
}
prepare_platform_import_defaults() {
if ! bool_enabled "$POC_ACCEPTANCE_IMPORT_RESULT"; then
return 0
fi
if [[ -z "$POC_ACCEPTANCE_IMPORT_API_BASE_URL" ]]; then
POC_ACCEPTANCE_IMPORT_API_BASE_URL="$(discover_import_api_base_url)"
export POC_ACCEPTANCE_IMPORT_API_BASE_URL
fi
if [[ -n "$POC_ACCEPTANCE_IMPORT_API_BASE_URL" ]]; then
load_import_api_token
fi
}
config_value() {
local key="$1"
kubectl -n "$K8S_NAMESPACE" get configmap droboticflow-config -o "jsonpath={.data.$key}" 2>/dev/null || true
}
validate_strict_scope() {
local missing=()
local external
for external in bos mongo; do
if ! required_external_enabled "$external"; then
missing+=("$external")
fi
done
if [[ "${#missing[@]}" -gt 0 ]]; then
echo "ERROR: acceptance:poc-strict requires POC_ACCEPTANCE_REQUIRED_EXTERNALS to include bos,mongo; missing: $(IFS=','; printf '%s' "${missing[*]}")" >&2
exit 1
fi
}
import_preflight_result_if_configured() {
local result_file="$1"
if ! bool_enabled "$POC_ACCEPTANCE_IMPORT_RESULT"; then
return 0
fi
if [[ -z "$POC_ACCEPTANCE_IMPORT_API_BASE_URL" ]]; then
echo "POC strict preflight platform import skipped: no API URL was configured and ${K8S_NAMESPACE}/${API_PUBLIC_SERVICE_NAME} has no discoverable LoadBalancer ingress." >&2
return 0
fi
local runner_image
runner_image="${OPERATOR_RUNNER_IMAGE:-$(config_value OPERATOR_RUNNER_IMAGE)}"
API_BASE_URL="$POC_ACCEPTANCE_IMPORT_API_BASE_URL" \
K8S_NAMESPACE="$K8S_NAMESPACE" \
OPERATOR_RUNNER_IMAGE="$runner_image" \
POC_OPERATOR_ACCEPTANCE_JOB_NAME="$POC_OPERATOR_ACCEPTANCE_JOB_NAME" \
python3 "$POC_STRICT_IMPORT_SCRIPT_PATH" \
--api-base-url "$POC_ACCEPTANCE_IMPORT_API_BASE_URL" \
--result-file "$result_file" \
--environment "${DEPLOY_ENV:-poc}" \
--namespace "$K8S_NAMESPACE" \
--job-name "$POC_OPERATOR_ACCEPTANCE_JOB_NAME" \
--runner-image "$runner_image"
}
emit_preflight_result_and_exit() {
local source="$1"
local input_file="$2"
local status="$3"
local result_file
result_file="$(mktemp)"
python3 "$POC_STRICT_PREFLIGHT_RESULT_SCRIPT_PATH" \
--source "$source" \
--input-json "$input_file" \
--run-id "$POC_OPERATOR_ACCEPTANCE_JOB_NAME" \
--namespace "$K8S_NAMESPACE" \
--required-externals "$POC_ACCEPTANCE_REQUIRED_EXTERNALS" >"$result_file"
cat "$result_file"
import_preflight_result_if_configured "$result_file"
rm -f "$result_file"
exit "$status"
}
run_preflight_or_exit() {
local label="$1"
local source="$2"
shift
shift
local output_file
local status
output_file="$(mktemp)"
set +e
"$@" >"$output_file"
status=$?
set -e
if [[ "$status" -ne 0 ]]; then
emit_preflight_result_and_exit "$source" "$output_file" "$status"
fi
rm -f "$output_file"
echo "POC strict preflight passed: $label" >&2
}
validate_file POC_STRICT_READINESS_SCRIPT_PATH "$POC_STRICT_READINESS_SCRIPT_PATH"
validate_file POC_STRICT_OPERATOR_ACCEPTANCE_SCRIPT_PATH "$POC_STRICT_OPERATOR_ACCEPTANCE_SCRIPT_PATH"
validate_file POC_STRICT_PREFLIGHT_RESULT_SCRIPT_PATH "$POC_STRICT_PREFLIGHT_RESULT_SCRIPT_PATH"
validate_file POC_STRICT_IMPORT_SCRIPT_PATH "$POC_STRICT_IMPORT_SCRIPT_PATH"
validate_strict_scope
prepare_platform_import_defaults
run_preflight_or_exit "readiness" "readiness" "$POC_STRICT_READINESS_SCRIPT_PATH"
"$POC_STRICT_OPERATOR_ACCEPTANCE_SCRIPT_PATH"