670 lines
25 KiB
Bash
Executable File
670 lines
25 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -u
|
|
set -o pipefail
|
|
|
|
LAUNCHER_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
|
|
INSTALLED_SUITE="$(cd -- "$LAUNCHER_DIR/.." && pwd -P)"
|
|
WORK_ROOT=""
|
|
|
|
print_usage() {
|
|
printf 'Uso:\n'
|
|
printf ' %s S03H3 <durata-secondi> MINIMAL\n' "$0"
|
|
printf ' %s S03H3 <durata-secondi> TEST\n' "$0"
|
|
printf ' %s S03H3 <durata-secondi> DIAGNOSTIC\n' "$0"
|
|
}
|
|
|
|
fail() {
|
|
local code="$1"
|
|
local reason="$2"
|
|
printf 'S03_H3_LAUNCHER_STATUS=FAIL\n' >&2
|
|
printf 'BLOCK_REASON=%s\n' "$reason" >&2
|
|
exit "$code"
|
|
}
|
|
|
|
is_positive_decimal() {
|
|
local value="$1"
|
|
[[ "$value" =~ ^[0-9]+$ ]] && [[ "$value" =~ [1-9] ]]
|
|
}
|
|
|
|
verify_hash() {
|
|
local file="$1"
|
|
local expected="$2"
|
|
local label="$3"
|
|
local actual
|
|
if [ ! -f "$file" ]; then
|
|
printf 'HASH_CHECK=%s STATUS=MISSING FILE=%s\n' "$label" "$file" >&2
|
|
return 1
|
|
fi
|
|
actual="$(sha256sum -- "$file" | awk '{print $1}')" || return 1
|
|
printf 'HASH_CHECK=%s EXPECTED=%s ACTUAL=%s FILE=%s\n' \
|
|
"$label" "$expected" "$actual" "$file"
|
|
[ "$actual" = "$expected" ]
|
|
}
|
|
|
|
readonly -a HISTORICAL_RELATIVE_PATHS=(
|
|
"launcher/marte_benchmark_launcher.sh"
|
|
"configurations/generated/S00/smoke_s0_core.marte"
|
|
"configurations/generated/S01/from_patcher/smoke_s1_timing_from_s00.marte"
|
|
"configurations/generated/S02/from_patcher/smoke_s2_binary_recording_from_s01.marte"
|
|
"configurations/generated/S03/from_patcher/smoke_s3_semantic_sentinels_from_s02.marte"
|
|
"patchers/configuration/build_s01_from_s00.sh"
|
|
"patchers/configuration/build_s02_from_s01.sh"
|
|
"patchers/configuration/build_s03_from_s02.sh"
|
|
"scenarios/S02_binary_recording/validate.sh"
|
|
"scenarios/S03_semantic_sentinels/validate.sh"
|
|
"scenarios/S03_semantic_sentinels/parse_s03_binary.py"
|
|
"common/marte_runner.sh"
|
|
"common/paths.sh"
|
|
"common/environment.sh"
|
|
"launcher/marte_benchmark_launcher_s03h1.sh"
|
|
"patchers/configuration/build_s03h1_from_s02.sh"
|
|
"scenarios/S03H1_execution_profiles/validate.sh"
|
|
"scenarios/S03H1_execution_profiles/verify_s03h1_config.py"
|
|
"scenarios/S03H1_execution_profiles/export_s03_csv.py"
|
|
"configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_test_from_s02.marte"
|
|
"configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_diagnostic_from_s02.marte"
|
|
)
|
|
|
|
readonly -a HISTORICAL_EXPECTED_HASHES=(
|
|
"7ef0419826c85c0364aad2403db4b8340cd815e9d9ce17edfbe5da8e6fbf2683"
|
|
"49a9b48595aab88cd8fd11d1e58ace4ab11d7d0a649e9b143bdc25c8866253d5"
|
|
"1513e1ca72eba56d53079ac7328908f12ddc72772456e2d75bcbacb6465d2427"
|
|
"8ecc8ba55e46e9f6fb8f304404d4070ff4c2ea5b9c783a69113bc08b457859d1"
|
|
"0f8916735ff67a9be2b167b52f147687fe131a063f410a81bfbf3bf9ff65f1e4"
|
|
"a8cced1ea1711806863606e27c3ba52a3e72794dbe8c36c253570709ce3f7ccb"
|
|
"8ac51d09f6f7984af3522e373bab59e2553775c418f69a53ccb93d8d1b893391"
|
|
"96c778ba6a15353fd969b19960706d7c0ca810c0c6fd61a14b5f88960e4e2b7a"
|
|
"7cd29b216b5edc3c72750a3326aebe5a9fdfb3b7522f1d7a6e8b0a1a97b3d60a"
|
|
"95caf207c4d29037c4973d756ff5a7004a3360aad9656d068948e222a4ba0c98"
|
|
"91c4d66770197e1986ed91eb6a4870e7da7df5a522ffdf4329b6d9250f238307"
|
|
"9e4f1a6b0dabc244fd0726fd18bf07e86b29a9fc6a76d54fcaf61c79f13c9633"
|
|
"468d92c3eb048b7137ea52a768f459d2d1f26f83f5a5c174d3333d032c9583c6"
|
|
"b1faa567e480c326c72107b886f387f108907900804621337524f1f856f056ac"
|
|
"f420afdff1f0a96026d14820662a4257c0da4924a491fe00182f838414e06152"
|
|
"5db5f71db4ab8f007b2e78230c2506bed4c62a8e502fb1c08ca04eb14b645b82"
|
|
"748f403a045f9dbed64910de67e75ba5529c02ab5894417a866225518c10b5e5"
|
|
"2f1c41b186bd2e79a9fb51fab0461a7a0dce104bf0852c0ec1ade2c55a017443"
|
|
"b413ad113e188141891b61b930a607890b8468051e8a61cb0f0454c519a51fb7"
|
|
"d037561b32760fbd0e2aec9f1eefc5efda27b1918eca4742c89092a8a2f7e92e"
|
|
"cd999ff249452298d650a22c8fe5b0b03bf48c0735f4630befdec8209cbb13a3"
|
|
)
|
|
|
|
readonly -a S03H3_ADD_RELATIVE_PATHS=(
|
|
"launcher/marte_benchmark_launcher_s03h3.sh"
|
|
"patchers/configuration/build_s03h3_minimal_from_s03h1_test.sh"
|
|
"scenarios/S03H3_execution_profiles/validate.sh"
|
|
"scenarios/S03H3_execution_profiles/verify_s03h3_minimal_structure.py"
|
|
"configurations/generated/S03H3/from_patcher/smoke_s03h3_execution_profiles_minimal_from_s03h1_test.marte"
|
|
)
|
|
|
|
readonly EXPECTED_PATCHER_SHA256="b3ba3c195b33a028e7ae21ba92b90a070a5e3526b455f9e3dbcebe023af05e2e"
|
|
readonly EXPECTED_VALIDATOR_SHA256="8574636315340c785f41dca37eaac097cd3b59958e7fd1160444b9c21768f2d5"
|
|
readonly EXPECTED_MINIMAL_VERIFIER_SHA256="c8d2d4880ed9cb0e8f23427617e989f5f70e82a990a49489f2863a7b3fc2cb95"
|
|
readonly EXPECTED_MINIMAL_CONFIG_SHA256="2ee67c48d748e79ec7fdbc748bc4371eb02590d7522b41990d5cb2a3649796ec"
|
|
readonly EXPECTED_TEST_CONFIG_SHA256="d037561b32760fbd0e2aec9f1eefc5efda27b1918eca4742c89092a8a2f7e92e"
|
|
readonly EXPECTED_DIAGNOSTIC_CONFIG_SHA256="cd999ff249452298d650a22c8fe5b0b03bf48c0735f4630befdec8209cbb13a3"
|
|
|
|
resolve_suite() {
|
|
if [ -n "${MARTE_BENCHMARK_SUITE_ROOT:-}" ]; then
|
|
[[ "$MARTE_BENCHMARK_SUITE_ROOT" = /* ]] || \
|
|
fail 50 "TEST_OVERRIDE_NOT_ABSOLUTE"
|
|
[ -d "$MARTE_BENCHMARK_SUITE_ROOT" ] || \
|
|
fail 50 "TEST_OVERRIDE_ROOT_MISSING"
|
|
SUITE="$(cd -- "$MARTE_BENCHMARK_SUITE_ROOT" && pwd -P)"
|
|
[ -n "$SUITE" ] && [ "$SUITE" != "/" ] || \
|
|
fail 50 "TEST_OVERRIDE_ROOT_UNSAFE"
|
|
if [ "$SUITE" != "$INSTALLED_SUITE" ]; then
|
|
[ "${S03H3_TEST_ONLY_OVERRIDE:-NO}" = "YES" ] || \
|
|
fail 50 "TEST_OVERRIDE_NOT_ACKNOWLEDGED"
|
|
fi
|
|
elif [ "${S03H3_TEST_ONLY_OVERRIDE:-NO}" = "YES" ]; then
|
|
fail 50 "TEST_OVERRIDE_ROOT_NOT_PROVIDED"
|
|
else
|
|
SUITE="$INSTALLED_SUITE"
|
|
fi
|
|
readonly SUITE
|
|
}
|
|
|
|
verify_historical_baseline() {
|
|
local index=0
|
|
while [ "$index" -lt "${#HISTORICAL_RELATIVE_PATHS[@]}" ]; do
|
|
verify_hash \
|
|
"$SUITE/${HISTORICAL_RELATIVE_PATHS[$index]}" \
|
|
"${HISTORICAL_EXPECTED_HASHES[$index]}" \
|
|
"HISTORICAL_${index}" || return 1
|
|
index=$((index + 1))
|
|
done
|
|
}
|
|
|
|
verify_candidate_components() {
|
|
verify_hash "$PATCHER" "$EXPECTED_PATCHER_SHA256" "S03H3_PATCHER" || return 1
|
|
verify_hash "$VALIDATOR" "$EXPECTED_VALIDATOR_SHA256" "S03H3_VALIDATOR" || return 1
|
|
verify_hash "$MINIMAL_VERIFIER" "$EXPECTED_MINIMAL_VERIFIER_SHA256" "S03H3_MINIMAL_VERIFIER" || return 1
|
|
verify_hash "$MINIMAL_CONFIG" "$EXPECTED_MINIMAL_CONFIG_SHA256" "S03H3_MINIMAL_CONFIG" || return 1
|
|
}
|
|
|
|
build_protected_paths() {
|
|
PROTECTED_PATHS=()
|
|
local relative
|
|
for relative in "${HISTORICAL_RELATIVE_PATHS[@]}"; do
|
|
PROTECTED_PATHS+=("$SUITE/$relative")
|
|
done
|
|
for relative in "${S03H3_ADD_RELATIVE_PATHS[@]}"; do
|
|
PROTECTED_PATHS+=("$SUITE/$relative")
|
|
done
|
|
PROTECTED_PATHS+=("$SUITE/launcher/marte_benchmark_menu.sh")
|
|
}
|
|
|
|
write_protected_snapshot() {
|
|
local destination="$1"
|
|
[ "${#PROTECTED_PATHS[@]}" -eq 27 ] || return 1
|
|
sha256sum -- "${PROTECTED_PATHS[@]}" >"$destination"
|
|
}
|
|
|
|
write_protected_path_list() {
|
|
local destination="$1"
|
|
printf '%s\n' "${PROTECTED_PATHS[@]}" >"$destination"
|
|
}
|
|
|
|
parse_contract_field() {
|
|
local field="$1"
|
|
local file="$2"
|
|
local count
|
|
PARSED_FIELD_VALUE=""
|
|
PARSED_FIELD_ERROR=""
|
|
count="$(grep -Ec "^${field}=" "$file" || true)"
|
|
if [ "$count" -eq 0 ]; then
|
|
PARSED_FIELD_ERROR="MISSING"
|
|
return 1
|
|
fi
|
|
if [ "$count" -ne 1 ]; then
|
|
PARSED_FIELD_ERROR="DUPLICATED"
|
|
return 1
|
|
fi
|
|
PARSED_FIELD_VALUE="$(sed -n "s/^${field}=//p" "$file")"
|
|
[ -n "$PARSED_FIELD_VALUE" ] || {
|
|
PARSED_FIELD_ERROR="MALFORMED"
|
|
return 1
|
|
}
|
|
}
|
|
|
|
classify_s03h3_run() {
|
|
local validator_rc="$1"
|
|
local validation_tee_rc="$2"
|
|
local validation_file="$3"
|
|
local csv_rc="$4"
|
|
local invariance_status="$5"
|
|
local dependency_status="$6"
|
|
local requested_mode="$7"
|
|
local field
|
|
|
|
FINAL_RC=22
|
|
FINAL_RESULT="INCONCLUSIVE_S03H3_CONTRACT"
|
|
BLOCK_REASON="NOT_EVALUATED"
|
|
PARSED_MODE_STATUS="NOT_EVALUATED"
|
|
PARSED_PROFILE_CONFIG_STATUS="NOT_EVALUATED"
|
|
PARSED_PROFILE_RUNTIME_STATUS="NOT_EVALUATED"
|
|
PARSED_OBSERVABILITY_STATUS="NOT_EVALUATED"
|
|
PARSED_FUNCTIONAL_STATUS="NOT_EVALUATED"
|
|
PARSED_SEMANTIC_STATUS="NOT_EVALUATED"
|
|
PARSED_TIMING_STATUS="NOT_EVALUATED"
|
|
PARSED_MEASUREMENT_ELIGIBILITY="NOT_EVALUATED"
|
|
PARSED_COMPLETE_SAMPLE_COUNT="NOT_EVALUATED"
|
|
|
|
if [ "$dependency_status" != "PASS" ]; then
|
|
FINAL_RC=51
|
|
FINAL_RESULT="FAIL_DEPENDENCY_INTEGRITY"
|
|
BLOCK_REASON="DEPENDENCY_INTEGRITY_NOT_PASS"
|
|
return 0
|
|
fi
|
|
if [ "$validation_tee_rc" -ne 0 ]; then
|
|
FINAL_RC=67
|
|
FINAL_RESULT="FAIL_VALIDATION_LOG"
|
|
BLOCK_REASON="VALIDATION_LOG_NOT_WRITTEN"
|
|
return 0
|
|
fi
|
|
case "$validator_rc" in
|
|
0|10|11|20|21) ;;
|
|
*)
|
|
FINAL_RC=68
|
|
FINAL_RESULT="FAIL_VALIDATOR_EXIT"
|
|
BLOCK_REASON="UNRECOGNIZED_VALIDATOR_RC_${validator_rc}"
|
|
return 0
|
|
;;
|
|
esac
|
|
if [ "$csv_rc" -ne 0 ]; then
|
|
FINAL_RC=70
|
|
FINAL_RESULT="FAIL_DERIVED_CSV_EXPORT"
|
|
BLOCK_REASON="CSV_EXPORT_RC_${csv_rc}"
|
|
return 0
|
|
fi
|
|
if [ "$invariance_status" != "PASS" ]; then
|
|
FINAL_RC=71
|
|
FINAL_RESULT="FAIL_PROTECTED_BASELINE_CHANGED"
|
|
BLOCK_REASON="PROTECTED_BASELINE_INVARIANCE_${invariance_status}"
|
|
return 0
|
|
fi
|
|
|
|
CONTRACT_PARSE_ERROR="NONE"
|
|
for field in \
|
|
MODE \
|
|
MODE_STATUS \
|
|
PROFILE_CONFIG_STATUS \
|
|
PROFILE_RUNTIME_STATUS \
|
|
OBSERVABILITY_STATUS \
|
|
OBSERVABILITY_REASON \
|
|
FUNCTIONAL_STATUS \
|
|
SEMANTIC_STATUS \
|
|
TIMING_STATUS \
|
|
MEASUREMENT_ELIGIBILITY \
|
|
COMPLETE_SAMPLE_COUNT \
|
|
VALIDATION_RESULT
|
|
do
|
|
if parse_contract_field "$field" "$validation_file"; then
|
|
case "$field" in
|
|
MODE) PARSED_MODE="$PARSED_FIELD_VALUE" ;;
|
|
MODE_STATUS) PARSED_MODE_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
PROFILE_CONFIG_STATUS) PARSED_PROFILE_CONFIG_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
PROFILE_RUNTIME_STATUS) PARSED_PROFILE_RUNTIME_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
OBSERVABILITY_STATUS) PARSED_OBSERVABILITY_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
OBSERVABILITY_REASON) PARSED_OBSERVABILITY_REASON="$PARSED_FIELD_VALUE" ;;
|
|
FUNCTIONAL_STATUS) PARSED_FUNCTIONAL_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
SEMANTIC_STATUS) PARSED_SEMANTIC_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
TIMING_STATUS) PARSED_TIMING_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
MEASUREMENT_ELIGIBILITY) PARSED_MEASUREMENT_ELIGIBILITY="$PARSED_FIELD_VALUE" ;;
|
|
COMPLETE_SAMPLE_COUNT) PARSED_COMPLETE_SAMPLE_COUNT="$PARSED_FIELD_VALUE" ;;
|
|
VALIDATION_RESULT) PARSED_VALIDATION_RESULT="$PARSED_FIELD_VALUE" ;;
|
|
esac
|
|
elif [ "$CONTRACT_PARSE_ERROR" = "NONE" ]; then
|
|
CONTRACT_PARSE_ERROR="${field}_${PARSED_FIELD_ERROR}"
|
|
fi
|
|
done
|
|
|
|
if [ "$CONTRACT_PARSE_ERROR" = "NONE" ]; then
|
|
[ "$PARSED_MODE" = "$requested_mode" ] || CONTRACT_PARSE_ERROR="MODE_MISMATCH"
|
|
for field in \
|
|
"$PARSED_MODE_STATUS" \
|
|
"$PARSED_PROFILE_CONFIG_STATUS" \
|
|
"$PARSED_PROFILE_RUNTIME_STATUS" \
|
|
"$PARSED_OBSERVABILITY_STATUS" \
|
|
"$PARSED_FUNCTIONAL_STATUS" \
|
|
"$PARSED_SEMANTIC_STATUS"
|
|
do
|
|
case "$field" in
|
|
PASS|FAIL|NOT_DEMONSTRATED) ;;
|
|
*) CONTRACT_PARSE_ERROR="STATUS_VOCABULARY_INVALID"; break ;;
|
|
esac
|
|
done
|
|
fi
|
|
if [ "$CONTRACT_PARSE_ERROR" = "NONE" ]; then
|
|
[[ "$PARSED_OBSERVABILITY_REASON" =~ ^[A-Z][A-Z0-9_]*$ ]] || \
|
|
CONTRACT_PARSE_ERROR="OBSERVABILITY_REASON_MALFORMED"
|
|
[[ "$PARSED_TIMING_STATUS" =~ ^(NOT_VALID_|UNASSESSED_)[A-Z0-9_]+$ ]] || \
|
|
CONTRACT_PARSE_ERROR="TIMING_STATUS_UNRECOGNIZED"
|
|
[ "$PARSED_MEASUREMENT_ELIGIBILITY" = "NO" ] || \
|
|
CONTRACT_PARSE_ERROR="ELIGIBILITY_CONTRACT_VIOLATION"
|
|
[[ "$PARSED_COMPLETE_SAMPLE_COUNT" =~ ^[0-9]+$ ]] || \
|
|
CONTRACT_PARSE_ERROR="COMPLETE_SAMPLE_COUNT_MALFORMED"
|
|
[[ "$PARSED_VALIDATION_RESULT" =~ ^[A-Z][A-Z0-9_]*$ ]] || \
|
|
CONTRACT_PARSE_ERROR="VALIDATION_RESULT_MALFORMED"
|
|
if [ "$PARSED_OBSERVABILITY_STATUS" = "PASS" ]; then
|
|
[ "$PARSED_OBSERVABILITY_REASON" = "NONE" ] || \
|
|
CONTRACT_PARSE_ERROR="OBSERVABILITY_REASON_CONFLICT"
|
|
else
|
|
[ "$PARSED_OBSERVABILITY_REASON" != "NONE" ] || \
|
|
CONTRACT_PARSE_ERROR="OBSERVABILITY_REASON_MISSING"
|
|
fi
|
|
case "$validator_rc:$PARSED_VALIDATION_RESULT" in
|
|
0:PASS_CLEAN_SHUTDOWN|\
|
|
10:PASS_KNOWN_SHUTDOWN_ANOMALY|\
|
|
11:PASS_UNCLASSIFIED_SHUTDOWN_ANOMALY|\
|
|
20:FUNCTIONAL_OR_SEMANTIC_NOT_DEMONSTRATED|\
|
|
21:FAIL_REQUIRED_INPUT)
|
|
;;
|
|
*)
|
|
CONTRACT_PARSE_ERROR="VALIDATION_RESULT_RC_CONFLICT"
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
if [ "$requested_mode" = "MINIMAL" ]; then
|
|
for field in \
|
|
CANONICAL_STRUCTURAL_COMPLETENESS_STATUS \
|
|
MINIMAL_RUNTIME_CONFIG_STATUS
|
|
do
|
|
if parse_contract_field "$field" "$validation_file"; then
|
|
[ "$PARSED_FIELD_VALUE" = "PASS" ] || \
|
|
CONTRACT_PARSE_ERROR="${field}_NOT_PASS"
|
|
else
|
|
CONTRACT_PARSE_ERROR="${field}_${PARSED_FIELD_ERROR}"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if [ "$CONTRACT_PARSE_ERROR" != "NONE" ]; then
|
|
FINAL_RC=22
|
|
FINAL_RESULT="INCONCLUSIVE_S03H3_CONTRACT"
|
|
BLOCK_REASON="$CONTRACT_PARSE_ERROR"
|
|
return 0
|
|
fi
|
|
|
|
case "$validator_rc" in
|
|
11|20|21)
|
|
FINAL_RC=20
|
|
FINAL_RESULT="S03H3_VALIDATION_INCONCLUSIVE"
|
|
BLOCK_REASON="VALIDATOR_RC_${validator_rc}"
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
for field in \
|
|
"$PARSED_MODE_STATUS" \
|
|
"$PARSED_PROFILE_CONFIG_STATUS" \
|
|
"$PARSED_PROFILE_RUNTIME_STATUS" \
|
|
"$PARSED_OBSERVABILITY_STATUS" \
|
|
"$PARSED_FUNCTIONAL_STATUS" \
|
|
"$PARSED_SEMANTIC_STATUS"
|
|
do
|
|
if [ "$field" != "PASS" ]; then
|
|
FINAL_RC=25
|
|
FINAL_RESULT="S03H3_CONTRACT_STATUS_NOT_PASS"
|
|
BLOCK_REASON="MANDATORY_STATUS_NOT_PASS"
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
case "$PARSED_TIMING_STATUS" in
|
|
NOT_VALID_*)
|
|
FINAL_RC=14
|
|
FINAL_RESULT="FUNCTIONAL_AND_SEMANTIC_PASS_TIMING_NOT_VALID"
|
|
BLOCK_REASON="$PARSED_TIMING_STATUS"
|
|
;;
|
|
UNASSESSED_*)
|
|
FINAL_RC=15
|
|
FINAL_RESULT="FUNCTIONAL_AND_SEMANTIC_PASS_TIMING_UNASSESSED"
|
|
BLOCK_REASON="$PARSED_TIMING_STATUS"
|
|
;;
|
|
*)
|
|
FINAL_RC=22
|
|
FINAL_RESULT="INCONCLUSIVE_S03H3_CONTRACT"
|
|
BLOCK_REASON="TIMING_STATUS_UNRECOGNIZED"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
run_s03h3() {
|
|
local duration="$1"
|
|
MODE="$2"
|
|
local expected_selected_hash
|
|
local patcher_log
|
|
local protected_before
|
|
local capture
|
|
local run_dir
|
|
local validation_log
|
|
local csv_report
|
|
local launcher_summary
|
|
local protected_after
|
|
local invariance_report
|
|
local protected_path_list
|
|
|
|
resolve_suite
|
|
[ -d "$SUITE" ] || return 50
|
|
|
|
PATCHER="$SUITE/patchers/configuration/build_s03h3_minimal_from_s03h1_test.sh"
|
|
VALIDATOR="$SUITE/scenarios/S03H3_execution_profiles/validate.sh"
|
|
MINIMAL_VERIFIER="$SUITE/scenarios/S03H3_execution_profiles/verify_s03h3_minimal_structure.py"
|
|
MINIMAL_CONFIG="$SUITE/configurations/generated/S03H3/from_patcher/smoke_s03h3_execution_profiles_minimal_from_s03h1_test.marte"
|
|
TEST_CONFIG="$SUITE/configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_test_from_s02.marte"
|
|
DIAGNOSTIC_CONFIG="$SUITE/configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_diagnostic_from_s02.marte"
|
|
RUNNER="$SUITE/common/marte_runner.sh"
|
|
LIVE_PATHS="$SUITE/common/paths.sh"
|
|
CSV_EXPORTER="$SUITE/scenarios/S03H1_execution_profiles/export_s03_csv.py"
|
|
PARSER="$SUITE/scenarios/S03_semantic_sentinels/parse_s03_binary.py"
|
|
|
|
case "$MODE" in
|
|
MINIMAL)
|
|
SELECTED_CONFIG="$MINIMAL_CONFIG"
|
|
expected_selected_hash="$EXPECTED_MINIMAL_CONFIG_SHA256"
|
|
;;
|
|
TEST)
|
|
SELECTED_CONFIG="$TEST_CONFIG"
|
|
expected_selected_hash="$EXPECTED_TEST_CONFIG_SHA256"
|
|
;;
|
|
DIAGNOSTIC)
|
|
SELECTED_CONFIG="$DIAGNOSTIC_CONFIG"
|
|
expected_selected_hash="$EXPECTED_DIAGNOSTIC_CONFIG_SHA256"
|
|
;;
|
|
*) return 2 ;;
|
|
esac
|
|
|
|
verify_historical_baseline || return 52
|
|
verify_candidate_components || return 51
|
|
verify_hash "$SELECTED_CONFIG" "$expected_selected_hash" "SELECTED_${MODE}_CONFIG" || return 51
|
|
build_protected_paths
|
|
local protected_path
|
|
for protected_path in "${PROTECTED_PATHS[@]}"; do
|
|
[ -f "$protected_path" ] || return 51
|
|
done
|
|
|
|
WORK_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/s03h3_launcher.XXXXXX")" || return 53
|
|
trap 'rm -rf -- "$WORK_ROOT"' EXIT HUP INT TERM
|
|
patcher_log="$WORK_ROOT/patcher.log"
|
|
protected_before="$WORK_ROOT/protected_before.sha256"
|
|
capture="$WORK_ROOT/runner_capture.log"
|
|
|
|
"$PATCHER" >"$patcher_log" 2>&1
|
|
PATCHER_RC=$?
|
|
[ "$PATCHER_RC" -eq 0 ] || return 54
|
|
verify_hash "$MINIMAL_CONFIG" "$EXPECTED_MINIMAL_CONFIG_SHA256" "MINIMAL_REGENERATION" || return 55
|
|
python3 "$MINIMAL_VERIFIER" CANONICAL "$TEST_CONFIG" "$MINIMAL_CONFIG" >/dev/null 2>&1 || return 55
|
|
write_protected_snapshot "$protected_before" || return 56
|
|
|
|
[ -f "$LIVE_PATHS" ] || return 57
|
|
# shellcheck source=/dev/null
|
|
source "$LIVE_PATHS" || return 57
|
|
CONSTANT_GAM_LIB_DIR="$MARTE2_COMPONENTS_ROOT/Build/$MARTE_TARGET/Components/GAMs/ConstantGAM"
|
|
CONSTANT_GAM_LIB="$CONSTANT_GAM_LIB_DIR/ConstantGAM.so"
|
|
[ -f "$CONSTANT_GAM_LIB" ] || return 58
|
|
case ":${LD_LIBRARY_PATH-}:" in
|
|
*":${CONSTANT_GAM_LIB_DIR}:"*) ;;
|
|
*) LD_LIBRARY_PATH="${CONSTANT_GAM_LIB_DIR}${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}" ;;
|
|
esac
|
|
export LD_LIBRARY_PATH
|
|
|
|
printf '============================================================\n'
|
|
printf 'S03-H3 EXECUTION PROFILES\n'
|
|
printf '============================================================\n'
|
|
printf 'MODE=%s\n' "$MODE"
|
|
printf 'DURATION=%s\n' "$duration"
|
|
printf 'DEPENDENCY_INTEGRITY_STATUS=PASS\n'
|
|
|
|
"$RUNNER" "S03H3_${MODE}_launcher" "$SELECTED_CONFIG" "State1" "$duration" \
|
|
2>&1 | tee "$capture"
|
|
RUNNER_CODES=("${PIPESTATUS[@]}")
|
|
RUNNER_RC="${RUNNER_CODES[0]}"
|
|
CAPTURE_TEE_RC="${RUNNER_CODES[1]}"
|
|
[ "$RUNNER_RC" -eq 0 ] || return 60
|
|
[ "$CAPTURE_TEE_RC" -eq 0 ] || return 61
|
|
|
|
run_dir="$(sed -n 's/^RUN_DIR=//p' "$capture" | tail -n 1)"
|
|
case "$run_dir" in
|
|
"$SUITE"/runs/*_S03H3_${MODE}_launcher) ;;
|
|
*) return 62 ;;
|
|
esac
|
|
[ -d "$run_dir" ] || return 62
|
|
|
|
RUN_LOG="$run_dir/run.log"
|
|
RUN_CONFIG="$run_dir/configuration.marte"
|
|
RUNNER_SUMMARY="$run_dir/runner_summary.txt"
|
|
RUN_HASHES="$run_dir/hashes.sha256"
|
|
OUTPUT_FILE="$run_dir/s03_output.bin"
|
|
CSV_FILE="$run_dir/s03_output.csv"
|
|
MODE_FILE="$run_dir/s03h3_mode.txt"
|
|
validation_log="$run_dir/validation.txt"
|
|
csv_report="$run_dir/csv_export.txt"
|
|
launcher_summary="$run_dir/launcher_summary.txt"
|
|
PROTECTED_BEFORE_RUN="$run_dir/protected_baseline_before.sha256"
|
|
protected_after="$run_dir/protected_baseline_after.sha256"
|
|
invariance_report="$run_dir/protected_baseline_invariance.txt"
|
|
protected_path_list="$run_dir/protected_successor_paths.txt"
|
|
|
|
for protected_path in "$RUN_LOG" "$RUN_CONFIG" "$RUNNER_SUMMARY" "$RUN_HASHES" "$OUTPUT_FILE"; do
|
|
[ -f "$protected_path" ] || return 63
|
|
done
|
|
|
|
cp -- "$protected_before" "$PROTECTED_BEFORE_RUN" || return 64
|
|
write_protected_path_list "$protected_path_list" || return 64
|
|
{
|
|
printf 'SCENARIO=S03H3\n'
|
|
printf 'MODE=%s\n' "$MODE"
|
|
printf 'SELECTED_CONFIG_SHA256=%s\n' "$expected_selected_hash"
|
|
} >"$MODE_FILE" || return 64
|
|
|
|
sha256sum -- \
|
|
"$MODE_FILE" \
|
|
"${BASH_SOURCE[0]}" \
|
|
"$PATCHER" \
|
|
"$VALIDATOR" \
|
|
"$MINIMAL_VERIFIER" \
|
|
"$CSV_EXPORTER" \
|
|
"$PARSER" \
|
|
"$RUN_LOG" \
|
|
"$RUNNER_SUMMARY" \
|
|
"$OUTPUT_FILE" \
|
|
"$PROTECTED_BEFORE_RUN" \
|
|
"$protected_path_list" \
|
|
"${PROTECTED_PATHS[@]}" \
|
|
>>"$RUN_HASHES" || return 64
|
|
|
|
timeout 30s "$VALIDATOR" "$MODE" "$run_dir" 2>&1 | tee "$validation_log"
|
|
VALIDATION_CODES=("${PIPESTATUS[@]}")
|
|
VALIDATOR_RC="${VALIDATION_CODES[0]}"
|
|
VALIDATION_TEE_RC="${VALIDATION_CODES[1]}"
|
|
|
|
"$CSV_EXPORTER" "$OUTPUT_FILE" "$CSV_FILE" >"$csv_report" 2>&1
|
|
CSV_EXPORT_RC=$?
|
|
if [ "$CSV_EXPORT_RC" -eq 0 ]; then
|
|
CSV_EXPORT_STATUS="PASS"
|
|
else
|
|
CSV_EXPORT_STATUS="FAIL"
|
|
fi
|
|
|
|
if write_protected_snapshot "$protected_after" && \
|
|
cmp -s -- "$PROTECTED_BEFORE_RUN" "$protected_after"; then
|
|
PROTECTED_BASELINE_INVARIANCE="PASS"
|
|
else
|
|
PROTECTED_BASELINE_INVARIANCE="FAIL"
|
|
fi
|
|
{
|
|
printf 'PROTECTED_BASELINE_INVARIANCE=%s\n' "$PROTECTED_BASELINE_INVARIANCE"
|
|
printf 'PROTECTED_SUCCESSOR_BASELINE_COUNT=27\n'
|
|
} >"$invariance_report"
|
|
|
|
for protected_path in "$validation_log" "$csv_report" "$protected_after" "$invariance_report"; do
|
|
[ -f "$protected_path" ] && sha256sum -- "$protected_path" >>"$RUN_HASHES"
|
|
done
|
|
[ -f "$CSV_FILE" ] && sha256sum -- "$CSV_FILE" >>"$RUN_HASHES"
|
|
|
|
classify_s03h3_run \
|
|
"$VALIDATOR_RC" \
|
|
"$VALIDATION_TEE_RC" \
|
|
"$validation_log" \
|
|
"$CSV_EXPORT_RC" \
|
|
"$PROTECTED_BASELINE_INVARIANCE" \
|
|
"PASS" \
|
|
"$MODE"
|
|
|
|
{
|
|
printf '============================================================\n'
|
|
printf 'RIEPILOGO LAUNCHER S03-H3\n'
|
|
printf '============================================================\n'
|
|
printf 'SCENARIO=S03H3\n'
|
|
printf 'MODE=%s\n' "$MODE"
|
|
printf 'DURATION=%s\n' "$duration"
|
|
printf 'RUN_DIR=%s\n' "$run_dir"
|
|
printf 'RUNNER_RC=%s\n' "$RUNNER_RC"
|
|
printf 'VALIDATOR_RC=%s\n' "$VALIDATOR_RC"
|
|
printf 'CSV_EXPORT_RC=%s\n' "$CSV_EXPORT_RC"
|
|
printf 'DEPENDENCY_INTEGRITY_STATUS=PASS\n'
|
|
printf 'PROTECTED_BASELINE_INVARIANCE=%s\n' "$PROTECTED_BASELINE_INVARIANCE"
|
|
printf 'CSV_EXPORT_STATUS=%s\n' "$CSV_EXPORT_STATUS"
|
|
printf 'MODE_STATUS=%s\n' "$PARSED_MODE_STATUS"
|
|
printf 'PROFILE_CONFIG_STATUS=%s\n' "$PARSED_PROFILE_CONFIG_STATUS"
|
|
printf 'PROFILE_RUNTIME_STATUS=%s\n' "$PARSED_PROFILE_RUNTIME_STATUS"
|
|
printf 'OBSERVABILITY_STATUS=%s\n' "$PARSED_OBSERVABILITY_STATUS"
|
|
printf 'FUNCTIONAL_STATUS=%s\n' "$PARSED_FUNCTIONAL_STATUS"
|
|
printf 'SEMANTIC_STATUS=%s\n' "$PARSED_SEMANTIC_STATUS"
|
|
printf 'TIMING_STATUS=%s\n' "$PARSED_TIMING_STATUS"
|
|
printf 'MEASUREMENT_ELIGIBILITY=NO\n'
|
|
printf 'BLOCK_REASON=%s\n' "$BLOCK_REASON"
|
|
printf 'FINAL_RESULT=%s\n' "$FINAL_RESULT"
|
|
printf 'FINAL_RC=%s\n' "$FINAL_RC"
|
|
printf 'PERFORMANCE_MEASUREMENT_AUTHORIZED=NO\n'
|
|
printf 'S04_AUTHORIZED=NO\n'
|
|
printf 'MD00_AUTHORIZED=NO\n'
|
|
} | tee "$launcher_summary"
|
|
SUMMARY_CODES=("${PIPESTATUS[@]}")
|
|
if [ "${SUMMARY_CODES[1]}" -ne 0 ]; then
|
|
FINAL_RC=69
|
|
FINAL_RESULT="FAIL_LAUNCHER_SUMMARY"
|
|
BLOCK_REASON="LAUNCHER_SUMMARY_NOT_WRITTEN"
|
|
else
|
|
sha256sum -- "$launcher_summary" >>"$RUN_HASHES"
|
|
fi
|
|
|
|
printf 'RUN_DIR=%s\n' "$run_dir"
|
|
printf 'FINAL_RESULT=%s\n' "$FINAL_RESULT"
|
|
printf 'FINAL_RC=%s\n' "$FINAL_RC"
|
|
|
|
rm -rf -- "$WORK_ROOT"
|
|
WORK_ROOT=""
|
|
trap - EXIT HUP INT TERM
|
|
return "$FINAL_RC"
|
|
}
|
|
|
|
if [ "${S03H3_LAUNCHER_LIB_ONLY:-0}" = "1" ]; then
|
|
if [ "${BASH_SOURCE[0]}" != "$0" ]; then
|
|
return 0
|
|
fi
|
|
printf 'S03H3_LAUNCHER_LIB_ONLY=1 richiede source.\n' >&2
|
|
exit 3
|
|
fi
|
|
|
|
case "$#" in
|
|
1)
|
|
case "$1" in
|
|
-h|--help)
|
|
print_usage
|
|
exit 0
|
|
;;
|
|
*)
|
|
print_usage >&2
|
|
exit 2
|
|
;;
|
|
esac
|
|
;;
|
|
3)
|
|
[ "$1" = "S03H3" ] || {
|
|
print_usage >&2
|
|
exit 2
|
|
}
|
|
is_positive_decimal "$2" || {
|
|
printf 'Durata non valida: %s\n' "$2" >&2
|
|
exit 2
|
|
}
|
|
case "$3" in
|
|
MINIMAL|TEST|DIAGNOSTIC) ;;
|
|
*)
|
|
printf 'Profilo non riconosciuto: %s\n' "$3" >&2
|
|
exit 2
|
|
;;
|
|
esac
|
|
run_s03h3 "$2" "$3"
|
|
exit $?
|
|
;;
|
|
*)
|
|
print_usage >&2
|
|
exit 2
|
|
;;
|
|
esac
|