forked from longtao.wu/droboticflow
422 lines
17 KiB
Bash
Executable File
422 lines
17 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
|
|
DEPLOY_ENV="${DEPLOY_ENV:-}"
|
|
|
|
if [[ $# -gt 0 && -z "$DEPLOY_ENV" && "${1:-}" != -* ]]; then
|
|
DEPLOY_ENV="$1"
|
|
shift
|
|
fi
|
|
|
|
export DEPLOY_ENV
|
|
# shellcheck source=scripts/load-deploy-env.sh
|
|
source "$ROOT_DIR/scripts/load-deploy-env.sh"
|
|
|
|
K8S_NAMESPACE="${K8S_NAMESPACE:-droboticflow}"
|
|
WORKSPACE_MOUNT_PATH="${WORKSPACE_MOUNT_PATH:-/workspace}"
|
|
POC_ACCEPTANCE_FIXTURE_TARGET_DIR="${POC_ACCEPTANCE_FIXTURE_TARGET_DIR:-$WORKSPACE_MOUNT_PATH/datasets/fixtures/poc-operator-acceptance}"
|
|
POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH="${POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH:-$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/poc-operator-acceptance.json}"
|
|
POC_ACCEPTANCE_FIXTURE_DRY_RUN="${POC_ACCEPTANCE_FIXTURE_DRY_RUN:-false}"
|
|
|
|
boolean_true() {
|
|
local value
|
|
value="$(printf '%s' "${2:-}" | tr '[:upper:]' '[:lower:]')"
|
|
case "$value" in
|
|
1|true|yes|y|on)
|
|
return 0
|
|
;;
|
|
0|false|no|n|off|"")
|
|
return 1
|
|
;;
|
|
*)
|
|
echo "ERROR: $1 must be a boolean value, got '$2'." >&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
validate_dns_label() {
|
|
local name="$1"
|
|
local value="$2"
|
|
if [[ ! "$value" =~ ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$ ]] || [[ "${#value}" -gt 63 ]]; then
|
|
echo "ERROR: $name must be a lowercase Kubernetes DNS label, got '$value'." >&2
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
validate_workspace_path() {
|
|
local name="$1"
|
|
local value="$2"
|
|
if [[ -z "$value" ]] || ! [[ "$value" =~ ^/[-A-Za-z0-9._/]+$ ]]; then
|
|
echo "ERROR: $name must be an absolute workspace path without spaces." >&2
|
|
exit 1
|
|
fi
|
|
case "$value" in
|
|
"$WORKSPACE_MOUNT_PATH"|"$WORKSPACE_MOUNT_PATH"/*) ;;
|
|
*)
|
|
echo "ERROR: $name must point under WORKSPACE_MOUNT_PATH $WORKSPACE_MOUNT_PATH, got '$value'." >&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
validate_local_path() {
|
|
local name="$1"
|
|
local value="$2"
|
|
local kind="$3"
|
|
if [[ -z "$value" ]]; then
|
|
echo "ERROR: $name is required." >&2
|
|
exit 1
|
|
fi
|
|
if [[ "$kind" == "file" ]]; then
|
|
if [[ ! -f "$value" || ! -r "$value" || ! -s "$value" ]]; then
|
|
echo "ERROR: $name must point to a readable non-empty local file: $value" >&2
|
|
exit 1
|
|
fi
|
|
elif [[ "$kind" == "dir" ]]; then
|
|
if [[ ! -d "$value" || ! -r "$value" ]]; then
|
|
echo "ERROR: $name must point to a readable local directory: $value" >&2
|
|
exit 1
|
|
fi
|
|
if [[ -z "$(find "$value" -mindepth 1 -print -quit)" ]]; then
|
|
echo "ERROR: $name must point to a non-empty local directory: $value" >&2
|
|
exit 1
|
|
fi
|
|
elif [[ "$kind" == "any" ]]; then
|
|
if [[ -f "$value" ]]; then
|
|
validate_local_path "$name" "$value" file
|
|
elif [[ -d "$value" ]]; then
|
|
validate_local_path "$name" "$value" dir
|
|
else
|
|
echo "ERROR: $name must point to a readable non-empty local file or directory: $value" >&2
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "ERROR: internal unsupported local path kind '$kind'." >&2
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
workspace_path_from_source() {
|
|
local env_name="$1"
|
|
local local_env_name="$2"
|
|
local kind="$3"
|
|
local target_path="$4"
|
|
local value="${!env_name:-}"
|
|
local local_value="${!local_env_name:-}"
|
|
|
|
if [[ -n "$value" && "$value" == "$WORKSPACE_MOUNT_PATH"* ]]; then
|
|
validate_workspace_path "$env_name" "$value"
|
|
printf '%s\n' "$value"
|
|
return 0
|
|
fi
|
|
|
|
if [[ -n "$local_value" ]]; then
|
|
validate_local_path "$local_env_name" "$local_value" "$kind"
|
|
printf '%s\n' "$target_path"
|
|
return 0
|
|
fi
|
|
|
|
if [[ -n "$value" ]]; then
|
|
validate_local_path "$env_name" "$value" "$kind"
|
|
printf '%s\n' "$target_path"
|
|
return 0
|
|
fi
|
|
|
|
echo "ERROR: provide $local_env_name=<local-path> or $env_name=<workspace-or-local-path>." >&2
|
|
exit 1
|
|
}
|
|
|
|
source_path_for_copy() {
|
|
local env_name="$1"
|
|
local local_env_name="$2"
|
|
local value="${!env_name:-}"
|
|
local local_value="${!local_env_name:-}"
|
|
if [[ -n "$local_value" ]]; then
|
|
printf '%s\n' "$local_value"
|
|
return 0
|
|
fi
|
|
if [[ -n "$value" && "$value" != "$WORKSPACE_MOUNT_PATH"* ]]; then
|
|
printf '%s\n' "$value"
|
|
fi
|
|
}
|
|
|
|
workspace_kind_for_copy() {
|
|
local path="$1"
|
|
local kind="$2"
|
|
if [[ "$kind" == "any" ]]; then
|
|
if [[ -d "$path" ]]; then
|
|
printf 'dir\n'
|
|
else
|
|
printf 'file\n'
|
|
fi
|
|
else
|
|
printf '%s\n' "$kind"
|
|
fi
|
|
}
|
|
|
|
json_string() {
|
|
python3 - "$1" <<'PY'
|
|
import json
|
|
import sys
|
|
|
|
print(json.dumps(sys.argv[1], ensure_ascii=False))
|
|
PY
|
|
}
|
|
|
|
copy_file_to_workspace() {
|
|
local api_pod="$1"
|
|
local source_path="$2"
|
|
local target_path="$3"
|
|
kubectl -n "$K8S_NAMESPACE" exec -i "$api_pod" -- sh -c 'mkdir -p "$(dirname "$1")" && cat > "$1" && test -s "$1"' -- "$target_path" <"$source_path"
|
|
}
|
|
|
|
copy_dir_to_workspace() {
|
|
local api_pod="$1"
|
|
local source_path="$2"
|
|
local target_path="$3"
|
|
(cd "$source_path" && tar -cf - .) | kubectl -n "$K8S_NAMESPACE" exec -i "$api_pod" -- sh -c 'rm -rf "$1" && mkdir -p "$1" && tar -xf - -C "$1" && test -d "$1"' -- "$target_path"
|
|
}
|
|
|
|
verify_workspace_remote_path() {
|
|
local api_pod="$1"
|
|
local name="$2"
|
|
local path="$3"
|
|
local kind="$4"
|
|
local test_script
|
|
case "$kind" in
|
|
file)
|
|
test_script='test -f "$1" && test -r "$1" && test -s "$1"'
|
|
;;
|
|
dir)
|
|
test_script='test -d "$1" && test -r "$1"'
|
|
;;
|
|
any)
|
|
test_script='test -e "$1" && test -r "$1"'
|
|
;;
|
|
*)
|
|
echo "ERROR: internal unsupported remote path kind '$kind'." >&2
|
|
exit 1
|
|
;;
|
|
esac
|
|
if ! kubectl -n "$K8S_NAMESPACE" exec "$api_pod" -- sh -c "$test_script" -- "$path" >/dev/null; then
|
|
echo "ERROR: $name is not a readable non-empty $kind inside the POC workspace mount: $path" >&2
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
write_manifest_to_workspace() {
|
|
local api_pod="$1"
|
|
python3 - <<'PY' | kubectl -n "$K8S_NAMESPACE" exec -i "$api_pod" -- sh -c 'mkdir -p "$(dirname "$1")" && cat > "$1" && test -s "$1"' -- "$POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH"
|
|
import json
|
|
import os
|
|
|
|
payload = {
|
|
"fixtures": {
|
|
"xplatform": os.environ["POC_ACCEPTANCE_XPLATFORM_SOURCE_PATH"],
|
|
"csv": os.environ["POC_ACCEPTANCE_CSV_INPUT_PATH"],
|
|
"json": os.environ["POC_ACCEPTANCE_JSON_INPUT_PATH"],
|
|
"lerobot": os.environ["POC_ACCEPTANCE_LEROBOT_SOURCE_PATH"],
|
|
"rosbag": os.environ["POC_ACCEPTANCE_ROSBAG_SOURCE_PATH"],
|
|
"model": os.environ["POC_ACCEPTANCE_MODEL_JSON_PATH"],
|
|
},
|
|
"shellCommand": os.environ["POC_ACCEPTANCE_SHELL_COMMAND"],
|
|
}
|
|
yolo_data_yaml = os.getenv("POC_ACCEPTANCE_YOLO_DATA_YAML_PATH", "")
|
|
if yolo_data_yaml:
|
|
payload["fixtures"]["yolo"] = yolo_data_yaml
|
|
payload["fixtures"]["yolo_data_yaml"] = yolo_data_yaml
|
|
training_json = os.getenv("POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH", "")
|
|
if training_json:
|
|
payload["fixtures"]["training_json"] = training_json
|
|
payload["fixtures"]["policy_training_json"] = training_json
|
|
payload["fixtures"]["vla_training_json"] = training_json
|
|
payload["fixtures"]["openvla_training_json"] = training_json
|
|
yolo_onnx_model = os.getenv("POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH", "")
|
|
if yolo_onnx_model:
|
|
payload["fixtures"]["yolo_onnx_model"] = yolo_onnx_model
|
|
payload["fixtures"]["dnn_model_path"] = yolo_onnx_model
|
|
sections = {
|
|
"json": {
|
|
"filterField": os.getenv("POC_ACCEPTANCE_JSON_FILTER_FIELD", ""),
|
|
"filterExpected": os.getenv("POC_ACCEPTANCE_JSON_FILTER_EXPECTED", ""),
|
|
"extractField": os.getenv("POC_ACCEPTANCE_JSON_EXTRACT_FIELD", ""),
|
|
},
|
|
"video": {
|
|
"minClarity": os.getenv("POC_ACCEPTANCE_MIN_CLARITY", ""),
|
|
"maxShake": os.getenv("POC_ACCEPTANCE_MAX_SHAKE", ""),
|
|
"maxHandOcclusion": os.getenv("POC_ACCEPTANCE_MAX_HAND_OCCLUSION", ""),
|
|
"clarityScale": os.getenv("POC_ACCEPTANCE_CLARITY_SCALE", ""),
|
|
"segmentDurationSeconds": os.getenv("POC_ACCEPTANCE_SEGMENT_DURATION_SECONDS", ""),
|
|
"frameIntervalSeconds": os.getenv("POC_ACCEPTANCE_FRAME_INTERVAL_SECONDS", ""),
|
|
},
|
|
"xplatform": {
|
|
"dateStart": os.getenv("POC_ACCEPTANCE_XPLATFORM_DATE_START", ""),
|
|
"dateEnd": os.getenv("POC_ACCEPTANCE_XPLATFORM_DATE_END", ""),
|
|
"place": os.getenv("POC_ACCEPTANCE_XPLATFORM_PLACE", ""),
|
|
"type": os.getenv("POC_ACCEPTANCE_XPLATFORM_TYPE", ""),
|
|
},
|
|
}
|
|
for name, values in sections.items():
|
|
filtered = {key: value for key, value in values.items() if value != ""}
|
|
if filtered:
|
|
payload[name] = filtered
|
|
field_map = os.getenv("POC_ACCEPTANCE_JSON_FIELD_MAP_JSON", "")
|
|
if field_map:
|
|
payload.setdefault("json", {})["fieldMap"] = json.loads(field_map)
|
|
audit_rules = os.getenv("POC_ACCEPTANCE_AUDIT_RULES_JSON", "")
|
|
if audit_rules:
|
|
payload["audit"] = {"rules": json.loads(audit_rules)}
|
|
template_text = os.getenv("POC_ACCEPTANCE_TEMPLATE_TEXT", "")
|
|
if template_text:
|
|
payload.setdefault("json", {})["templateText"] = template_text
|
|
print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
|
|
PY
|
|
}
|
|
|
|
validate_dns_label K8S_NAMESPACE "$K8S_NAMESPACE"
|
|
validate_workspace_path WORKSPACE_MOUNT_PATH "$WORKSPACE_MOUNT_PATH"
|
|
validate_workspace_path POC_ACCEPTANCE_FIXTURE_TARGET_DIR "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR"
|
|
validate_workspace_path POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH "$POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH"
|
|
boolean_true POC_ACCEPTANCE_FIXTURE_DRY_RUN "$POC_ACCEPTANCE_FIXTURE_DRY_RUN" >/dev/null || true
|
|
|
|
if [[ -z "${POC_ACCEPTANCE_SHELL_COMMAND:-}" ]]; then
|
|
echo "ERROR: POC_ACCEPTANCE_SHELL_COMMAND is required and must be the real shell validation command for the target fixture bundle." >&2
|
|
exit 1
|
|
fi
|
|
|
|
csv_name="$(basename "${POC_ACCEPTANCE_LOCAL_CSV_INPUT_PATH:-${POC_ACCEPTANCE_CSV_INPUT_PATH:-records.csv}}")"
|
|
json_name="$(basename "${POC_ACCEPTANCE_LOCAL_JSON_INPUT_PATH:-${POC_ACCEPTANCE_JSON_INPUT_PATH:-records.json}}")"
|
|
training_json_name="$(basename "${POC_ACCEPTANCE_LOCAL_TRAINING_JSON_INPUT_PATH:-${POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH:-training-records.json}}")"
|
|
model_name="$(basename "${POC_ACCEPTANCE_LOCAL_MODEL_JSON_PATH:-${POC_ACCEPTANCE_MODEL_JSON_PATH:-model.json}}")"
|
|
yolo_data_yaml_name="$(basename "${POC_ACCEPTANCE_LOCAL_YOLO_DATA_YAML_PATH:-${POC_ACCEPTANCE_YOLO_DATA_YAML_PATH:-data.yaml}}")"
|
|
yolo_onnx_model_name="$(basename "${POC_ACCEPTANCE_LOCAL_YOLO_ONNX_MODEL_PATH:-${POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH:-yolov8n.onnx}}")"
|
|
|
|
export POC_ACCEPTANCE_XPLATFORM_SOURCE_PATH
|
|
export POC_ACCEPTANCE_CSV_INPUT_PATH
|
|
export POC_ACCEPTANCE_JSON_INPUT_PATH
|
|
export POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH
|
|
export POC_ACCEPTANCE_LEROBOT_SOURCE_PATH
|
|
export POC_ACCEPTANCE_ROSBAG_SOURCE_PATH
|
|
export POC_ACCEPTANCE_MODEL_JSON_PATH
|
|
export POC_ACCEPTANCE_YOLO_DATA_YAML_PATH
|
|
export POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH
|
|
POC_ACCEPTANCE_XPLATFORM_SOURCE_PATH="$(workspace_path_from_source POC_ACCEPTANCE_XPLATFORM_SOURCE_PATH POC_ACCEPTANCE_LOCAL_XPLATFORM_SOURCE_PATH dir "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/xplatform")"
|
|
POC_ACCEPTANCE_CSV_INPUT_PATH="$(workspace_path_from_source POC_ACCEPTANCE_CSV_INPUT_PATH POC_ACCEPTANCE_LOCAL_CSV_INPUT_PATH file "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/csv/$csv_name")"
|
|
POC_ACCEPTANCE_JSON_INPUT_PATH="$(workspace_path_from_source POC_ACCEPTANCE_JSON_INPUT_PATH POC_ACCEPTANCE_LOCAL_JSON_INPUT_PATH file "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/json/$json_name")"
|
|
if [[ -n "${POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH:-}" || -n "${POC_ACCEPTANCE_LOCAL_TRAINING_JSON_INPUT_PATH:-}" ]]; then
|
|
POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH="$(workspace_path_from_source POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH POC_ACCEPTANCE_LOCAL_TRAINING_JSON_INPUT_PATH file "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/json/$training_json_name")"
|
|
fi
|
|
POC_ACCEPTANCE_LEROBOT_SOURCE_PATH="$(workspace_path_from_source POC_ACCEPTANCE_LEROBOT_SOURCE_PATH POC_ACCEPTANCE_LOCAL_LEROBOT_SOURCE_PATH dir "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/lerobot")"
|
|
POC_ACCEPTANCE_ROSBAG_SOURCE_PATH="$(workspace_path_from_source POC_ACCEPTANCE_ROSBAG_SOURCE_PATH POC_ACCEPTANCE_LOCAL_ROSBAG_SOURCE_PATH any "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/rosbag")"
|
|
POC_ACCEPTANCE_MODEL_JSON_PATH="$(workspace_path_from_source POC_ACCEPTANCE_MODEL_JSON_PATH POC_ACCEPTANCE_LOCAL_MODEL_JSON_PATH file "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/model/$model_name")"
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_DATA_YAML_PATH:-}" || -n "${POC_ACCEPTANCE_LOCAL_YOLO_DATA_YAML_PATH:-}" ]]; then
|
|
POC_ACCEPTANCE_YOLO_DATA_YAML_PATH="$(workspace_path_from_source POC_ACCEPTANCE_YOLO_DATA_YAML_PATH POC_ACCEPTANCE_LOCAL_YOLO_DATA_YAML_PATH file "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/yolo/coco128/$yolo_data_yaml_name")"
|
|
fi
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH:-}" || -n "${POC_ACCEPTANCE_LOCAL_YOLO_ONNX_MODEL_PATH:-}" ]]; then
|
|
POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH="$(workspace_path_from_source POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH POC_ACCEPTANCE_LOCAL_YOLO_ONNX_MODEL_PATH file "$POC_ACCEPTANCE_FIXTURE_TARGET_DIR/yolo/models/$yolo_onnx_model_name")"
|
|
fi
|
|
|
|
for path_env in \
|
|
POC_ACCEPTANCE_XPLATFORM_SOURCE_PATH \
|
|
POC_ACCEPTANCE_CSV_INPUT_PATH \
|
|
POC_ACCEPTANCE_JSON_INPUT_PATH \
|
|
POC_ACCEPTANCE_LEROBOT_SOURCE_PATH \
|
|
POC_ACCEPTANCE_ROSBAG_SOURCE_PATH \
|
|
POC_ACCEPTANCE_MODEL_JSON_PATH
|
|
do
|
|
validate_workspace_path "$path_env" "${!path_env}"
|
|
done
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_DATA_YAML_PATH:-}" ]]; then
|
|
validate_workspace_path POC_ACCEPTANCE_YOLO_DATA_YAML_PATH "$POC_ACCEPTANCE_YOLO_DATA_YAML_PATH"
|
|
fi
|
|
if [[ -n "${POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH:-}" ]]; then
|
|
validate_workspace_path POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH "$POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH"
|
|
fi
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH:-}" ]]; then
|
|
validate_workspace_path POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH "$POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH"
|
|
fi
|
|
|
|
if boolean_true POC_ACCEPTANCE_FIXTURE_DRY_RUN "$POC_ACCEPTANCE_FIXTURE_DRY_RUN"; then
|
|
echo "POC acceptance fixture dry-run"
|
|
echo "namespace=$K8S_NAMESPACE"
|
|
echo "manifest=$POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH"
|
|
echo "xplatform=$POC_ACCEPTANCE_XPLATFORM_SOURCE_PATH"
|
|
echo "csv=$POC_ACCEPTANCE_CSV_INPUT_PATH"
|
|
echo "json=$POC_ACCEPTANCE_JSON_INPUT_PATH"
|
|
if [[ -n "${POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH:-}" ]]; then
|
|
echo "trainingJson=$POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH"
|
|
fi
|
|
echo "lerobot=$POC_ACCEPTANCE_LEROBOT_SOURCE_PATH"
|
|
echo "rosbag=$POC_ACCEPTANCE_ROSBAG_SOURCE_PATH"
|
|
echo "model=$POC_ACCEPTANCE_MODEL_JSON_PATH"
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_DATA_YAML_PATH:-}" ]]; then
|
|
echo "yoloDataYaml=$POC_ACCEPTANCE_YOLO_DATA_YAML_PATH"
|
|
fi
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH:-}" ]]; then
|
|
echo "yoloOnnxModel=$POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH"
|
|
fi
|
|
echo "shellCommandConfigured=true"
|
|
exit 0
|
|
fi
|
|
|
|
kubectl get namespace "$K8S_NAMESPACE" >/dev/null
|
|
api_pod="$(kubectl -n "$K8S_NAMESPACE" get pod -l app=droboticflow-api -o jsonpath='{.items[0].metadata.name}')"
|
|
if [[ -z "$api_pod" ]]; then
|
|
echo "ERROR: no droboticflow-api pod is available in namespace $K8S_NAMESPACE." >&2
|
|
exit 1
|
|
fi
|
|
|
|
for spec in \
|
|
POC_ACCEPTANCE_XPLATFORM_SOURCE_PATH:POC_ACCEPTANCE_LOCAL_XPLATFORM_SOURCE_PATH:dir \
|
|
POC_ACCEPTANCE_CSV_INPUT_PATH:POC_ACCEPTANCE_LOCAL_CSV_INPUT_PATH:file \
|
|
POC_ACCEPTANCE_JSON_INPUT_PATH:POC_ACCEPTANCE_LOCAL_JSON_INPUT_PATH:file \
|
|
POC_ACCEPTANCE_LEROBOT_SOURCE_PATH:POC_ACCEPTANCE_LOCAL_LEROBOT_SOURCE_PATH:dir \
|
|
POC_ACCEPTANCE_ROSBAG_SOURCE_PATH:POC_ACCEPTANCE_LOCAL_ROSBAG_SOURCE_PATH:any \
|
|
POC_ACCEPTANCE_MODEL_JSON_PATH:POC_ACCEPTANCE_LOCAL_MODEL_JSON_PATH:file
|
|
do
|
|
IFS=':' read -r env_name local_env_name expected_kind <<< "$spec"
|
|
source_path="$(source_path_for_copy "$env_name" "$local_env_name")"
|
|
target_path="${!env_name}"
|
|
if [[ -z "$source_path" ]]; then
|
|
verify_workspace_remote_path "$api_pod" "$env_name" "$target_path" "$expected_kind"
|
|
continue
|
|
fi
|
|
actual_kind="$(workspace_kind_for_copy "$source_path" "$expected_kind")"
|
|
if [[ "$actual_kind" == "dir" ]]; then
|
|
copy_dir_to_workspace "$api_pod" "$source_path" "$target_path"
|
|
else
|
|
copy_file_to_workspace "$api_pod" "$source_path" "$target_path"
|
|
fi
|
|
verify_workspace_remote_path "$api_pod" "$env_name" "$target_path" "$expected_kind"
|
|
done
|
|
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_DATA_YAML_PATH:-}" ]]; then
|
|
source_path="$(source_path_for_copy POC_ACCEPTANCE_YOLO_DATA_YAML_PATH POC_ACCEPTANCE_LOCAL_YOLO_DATA_YAML_PATH)"
|
|
if [[ -n "$source_path" ]]; then
|
|
copy_file_to_workspace "$api_pod" "$source_path" "$POC_ACCEPTANCE_YOLO_DATA_YAML_PATH"
|
|
fi
|
|
verify_workspace_remote_path "$api_pod" POC_ACCEPTANCE_YOLO_DATA_YAML_PATH "$POC_ACCEPTANCE_YOLO_DATA_YAML_PATH" file
|
|
fi
|
|
if [[ -n "${POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH:-}" ]]; then
|
|
source_path="$(source_path_for_copy POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH POC_ACCEPTANCE_LOCAL_TRAINING_JSON_INPUT_PATH)"
|
|
if [[ -n "$source_path" ]]; then
|
|
copy_file_to_workspace "$api_pod" "$source_path" "$POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH"
|
|
fi
|
|
verify_workspace_remote_path "$api_pod" POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH "$POC_ACCEPTANCE_TRAINING_JSON_INPUT_PATH" file
|
|
fi
|
|
if [[ -n "${POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH:-}" ]]; then
|
|
source_path="$(source_path_for_copy POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH POC_ACCEPTANCE_LOCAL_YOLO_ONNX_MODEL_PATH)"
|
|
if [[ -n "$source_path" ]]; then
|
|
copy_file_to_workspace "$api_pod" "$source_path" "$POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH"
|
|
fi
|
|
verify_workspace_remote_path "$api_pod" POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH "$POC_ACCEPTANCE_YOLO_ONNX_MODEL_PATH" file
|
|
fi
|
|
|
|
write_manifest_to_workspace "$api_pod"
|
|
verify_workspace_remote_path "$api_pod" POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH "$POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH" file
|
|
|
|
echo "POC acceptance fixtures applied: namespace=$K8S_NAMESPACE manifest=$POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH"
|
|
echo "export POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH=$(json_string "$POC_ACCEPTANCE_FIXTURE_MANIFEST_PATH")"
|