forked from longtao.wu/droboticflow
244 lines
7.9 KiB
Bash
Executable File
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"
|