573 lines
20 KiB
Bash
Executable File
573 lines
20 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -u
|
|
|
|
LAUNCHER_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
CANDIDATE_ROOT="$(cd "$LAUNCHER_DIR/.." && pwd)"
|
|
|
|
if [ -n "${MARTE_BENCHMARK_SUITE_ROOT:-}" ]; then
|
|
SUITE="$(cd "$MARTE_BENCHMARK_SUITE_ROOT" && pwd)"
|
|
else
|
|
SUITE="/home/dariodf/Scrivania/MARTE/marte-benchmark-suite"
|
|
fi
|
|
|
|
PATCHER="$CANDIDATE_ROOT/patchers/configuration/build_s03h1_from_s02.sh"
|
|
VALIDATOR="$CANDIDATE_ROOT/scenarios/S03H1_execution_profiles/validate.sh"
|
|
CONFIG_VERIFIER="$CANDIDATE_ROOT/scenarios/S03H1_execution_profiles/verify_s03h1_config.py"
|
|
CSV_EXPORTER="$CANDIDATE_ROOT/scenarios/S03H1_execution_profiles/export_s03_csv.py"
|
|
TEST_CONFIG="$CANDIDATE_ROOT/configurations/generated/S03H1/from_patcher/smoke_s03h1_execution_profiles_test_from_s02.marte"
|
|
DIAGNOSTIC_CONFIG="$CANDIDATE_ROOT/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"
|
|
LIVE_ENVIRONMENT="$SUITE/common/environment.sh"
|
|
LIVE_OPERATIONAL_LAUNCHER="$SUITE/launcher/marte_benchmark_launcher.sh"
|
|
LIVE_PATCHER_S01="$SUITE/patchers/configuration/build_s01_from_s00.sh"
|
|
LIVE_PATCHER_S02="$SUITE/patchers/configuration/build_s02_from_s01.sh"
|
|
LIVE_PATCHER_S03="$SUITE/patchers/configuration/build_s03_from_s02.sh"
|
|
LIVE_VALIDATOR_S02="$SUITE/scenarios/S02_binary_recording/validate.sh"
|
|
LIVE_VALIDATOR_S03="$SUITE/scenarios/S03_semantic_sentinels/validate.sh"
|
|
LIVE_PARSER_S03="$SUITE/scenarios/S03_semantic_sentinels/parse_s03_binary.py"
|
|
LIVE_S00_CONFIG="$SUITE/configurations/generated/S00/smoke_s0_core.marte"
|
|
LIVE_S01_CONFIG="$SUITE/configurations/generated/S01/from_patcher/smoke_s1_timing_from_s00.marte"
|
|
LIVE_S02_CONFIG="$SUITE/configurations/generated/S02/from_patcher/smoke_s2_binary_recording_from_s01.marte"
|
|
LIVE_S03_CONFIG="$SUITE/configurations/generated/S03/from_patcher/smoke_s3_semantic_sentinels_from_s02.marte"
|
|
|
|
EXPECTED_TEST_CONFIG_SHA256="d037561b32760fbd0e2aec9f1eefc5efda27b1918eca4742c89092a8a2f7e92e"
|
|
EXPECTED_DIAGNOSTIC_CONFIG_SHA256="cd999ff249452298d650a22c8fe5b0b03bf48c0735f4630befdec8209cbb13a3"
|
|
EXPECTED_PATCHER_SHA256="5db5f71db4ab8f007b2e78230c2506bed4c62a8e502fb1c08ca04eb14b645b82"
|
|
EXPECTED_VALIDATOR_SHA256="748f403a045f9dbed64910de67e75ba5529c02ab5894417a866225518c10b5e5"
|
|
EXPECTED_CONFIG_VERIFIER_SHA256="2f1c41b186bd2e79a9fb51fab0461a7a0dce104bf0852c0ec1ade2c55a017443"
|
|
EXPECTED_CSV_EXPORTER_SHA256="b413ad113e188141891b61b930a607890b8468051e8a61cb0f0454c519a51fb7"
|
|
|
|
print_usage() {
|
|
printf "Uso:\n"
|
|
printf " %s S03H1 <durata-secondi> TEST\n" "$0"
|
|
printf " %s S03H1 <durata-secondi> DIAGNOSTIC\n" "$0"
|
|
printf "\n"
|
|
printf "La candidata non installa e non modifica la baseline S03 R3.\n"
|
|
}
|
|
|
|
fail() {
|
|
code="$1"
|
|
shift
|
|
printf "S03_H1_LAUNCHER_STATUS=FAIL\n" >&2
|
|
printf "S03_H1_LAUNCHER_ERROR=%s\n" "$*" >&2
|
|
exit "$code"
|
|
}
|
|
|
|
validate_duration() {
|
|
candidate_duration="$1"
|
|
case "$candidate_duration" in
|
|
*[!0-9]*|"")
|
|
return 1
|
|
;;
|
|
esac
|
|
[ "$candidate_duration" -gt 0 ]
|
|
}
|
|
|
|
verify_hash() {
|
|
candidate_file="$1"
|
|
candidate_expected="$2"
|
|
candidate_label="$3"
|
|
if [ ! -f "$candidate_file" ]; then
|
|
printf "HASH_CHECK=%s STATUS=MISSING FILE=%s\n" \
|
|
"$candidate_label" "$candidate_file" >&2
|
|
return 1
|
|
fi
|
|
candidate_actual="$(sha256sum -- "$candidate_file" | awk '{print $1}')"
|
|
printf "HASH_CHECK=%s EXPECTED=%s ACTUAL=%s FILE=%s\n" \
|
|
"$candidate_label" "$candidate_expected" "$candidate_actual" "$candidate_file"
|
|
[ "$candidate_actual" = "$candidate_expected" ]
|
|
}
|
|
|
|
verify_candidate_components() {
|
|
verify_hash "$PATCHER" "$EXPECTED_PATCHER_SHA256" "S03H1_PATCHER" || return 1
|
|
verify_hash "$VALIDATOR" "$EXPECTED_VALIDATOR_SHA256" "S03H1_VALIDATOR" || return 1
|
|
verify_hash "$CONFIG_VERIFIER" "$EXPECTED_CONFIG_VERIFIER_SHA256" "S03H1_CONFIG_VERIFIER" || return 1
|
|
verify_hash "$CSV_EXPORTER" "$EXPECTED_CSV_EXPORTER_SHA256" "S03H1_CSV_EXPORTER" || return 1
|
|
verify_hash "$CANDIDATE_CONFIG" "$EXPECTED_CANDIDATE_CONFIG_SHA256" "S03H1_${MODE}_CONFIG" || return 1
|
|
return 0
|
|
}
|
|
|
|
PROTECTED_PATHS=(
|
|
"$LIVE_OPERATIONAL_LAUNCHER"
|
|
"$LIVE_S00_CONFIG"
|
|
"$LIVE_S01_CONFIG"
|
|
"$LIVE_S02_CONFIG"
|
|
"$LIVE_S03_CONFIG"
|
|
"$LIVE_PATCHER_S01"
|
|
"$LIVE_PATCHER_S02"
|
|
"$LIVE_PATCHER_S03"
|
|
"$LIVE_VALIDATOR_S02"
|
|
"$LIVE_VALIDATOR_S03"
|
|
"$LIVE_PARSER_S03"
|
|
"$RUNNER"
|
|
"$LIVE_PATHS"
|
|
"$LIVE_ENVIRONMENT"
|
|
)
|
|
PROTECTED_EXPECTED_HASHES=(
|
|
"7ef0419826c85c0364aad2403db4b8340cd815e9d9ce17edfbe5da8e6fbf2683"
|
|
"49a9b48595aab88cd8fd11d1e58ace4ab11d7d0a649e9b143bdc25c8866253d5"
|
|
"1513e1ca72eba56d53079ac7328908f12ddc72772456e2d75bcbacb6465d2427"
|
|
"8ecc8ba55e46e9f6fb8f304404d4070ff4c2ea5b9c783a69113bc08b457859d1"
|
|
"0f8916735ff67a9be2b167b52f147687fe131a063f410a81bfbf3bf9ff65f1e4"
|
|
"a8cced1ea1711806863606e27c3ba52a3e72794dbe8c36c253570709ce3f7ccb"
|
|
"8ac51d09f6f7984af3522e373bab59e2553775c418f69a53ccb93d8d1b893391"
|
|
"96c778ba6a15353fd969b19960706d7c0ca810c0c6fd61a14b5f88960e4e2b7a"
|
|
"7cd29b216b5edc3c72750a3326aebe5a9fdfb3b7522f1d7a6e8b0a1a97b3d60a"
|
|
"95caf207c4d29037c4973d756ff5a7004a3360aad9656d068948e222a4ba0c98"
|
|
"91c4d66770197e1986ed91eb6a4870e7da7df5a522ffdf4329b6d9250f238307"
|
|
"9e4f1a6b0dabc244fd0726fd18bf07e86b29a9fc6a76d54fcaf61c79f13c9633"
|
|
"468d92c3eb048b7137ea52a768f459d2d1f26f83f5a5c174d3333d032c9583c6"
|
|
"b1faa567e480c326c72107b886f387f108907900804621337524f1f856f056ac"
|
|
)
|
|
|
|
verify_protected_baseline() {
|
|
candidate_index=0
|
|
while [ "$candidate_index" -lt "${#PROTECTED_PATHS[@]}" ]; do
|
|
verify_hash \
|
|
"${PROTECTED_PATHS[$candidate_index]}" \
|
|
"${PROTECTED_EXPECTED_HASHES[$candidate_index]}" \
|
|
"PROTECTED_${candidate_index}" || return 1
|
|
candidate_index=$((candidate_index + 1))
|
|
done
|
|
return 0
|
|
}
|
|
|
|
write_protected_hashes() {
|
|
candidate_destination="$1"
|
|
sha256sum -- "${PROTECTED_PATHS[@]}" >"$candidate_destination"
|
|
}
|
|
|
|
parse_contract_field() {
|
|
candidate_field="$1"
|
|
candidate_file="$2"
|
|
PARSED_FIELD_VALUE=""
|
|
PARSED_FIELD_ERROR=""
|
|
if [ ! -f "$candidate_file" ]; then
|
|
PARSED_FIELD_ERROR="NO_FILE"
|
|
return 1
|
|
fi
|
|
candidate_count="$(grep -Ec "^${candidate_field}=[A-Z][A-Z0-9_]*$" "$candidate_file" || true)"
|
|
candidate_any_count="$(grep -Ec "^${candidate_field}=" "$candidate_file" || true)"
|
|
if [ "$candidate_any_count" -eq 0 ]; then
|
|
PARSED_FIELD_ERROR="MISSING"
|
|
return 1
|
|
fi
|
|
if [ "$candidate_any_count" -ne 1 ]; then
|
|
PARSED_FIELD_ERROR="DUPLICATED"
|
|
return 1
|
|
fi
|
|
if [ "$candidate_count" -ne 1 ]; then
|
|
PARSED_FIELD_ERROR="MALFORMED"
|
|
return 1
|
|
fi
|
|
PARSED_FIELD_VALUE="$(sed -n "s/^${candidate_field}=//p" "$candidate_file")"
|
|
return 0
|
|
}
|
|
|
|
classify_s03h1_run() {
|
|
classify_validator_rc="$1"
|
|
classify_tee_rc="$2"
|
|
classify_validation_file="$3"
|
|
classify_csv_rc="$4"
|
|
classify_invariance_status="$5"
|
|
|
|
FINAL_RC=20
|
|
FINAL_RESULT="INCONCLUSIVE"
|
|
BLOCK_REASON="NONE"
|
|
PARSED_MODE_STATUS="NOT_EVALUATED"
|
|
PARSED_PROFILE_CONFIG_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"
|
|
|
|
if [ "$classify_tee_rc" -ne 0 ]; then
|
|
FINAL_RC=67
|
|
FINAL_RESULT="FAIL_VALIDATION_LOG"
|
|
BLOCK_REASON="VALIDATION_LOG_NOT_WRITTEN"
|
|
return 0
|
|
fi
|
|
|
|
CONTRACT_PARSE_ERROR="NONE"
|
|
for candidate_field in \
|
|
MODE_STATUS \
|
|
PROFILE_CONFIG_STATUS \
|
|
OBSERVABILITY_STATUS \
|
|
FUNCTIONAL_STATUS \
|
|
SEMANTIC_STATUS \
|
|
TIMING_STATUS \
|
|
MEASUREMENT_ELIGIBILITY
|
|
do
|
|
if parse_contract_field "$candidate_field" "$classify_validation_file"; then
|
|
case "$candidate_field" in
|
|
MODE_STATUS) PARSED_MODE_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
PROFILE_CONFIG_STATUS) PARSED_PROFILE_CONFIG_STATUS="$PARSED_FIELD_VALUE" ;;
|
|
OBSERVABILITY_STATUS) PARSED_OBSERVABILITY_STATUS="$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" ;;
|
|
esac
|
|
elif [ "$CONTRACT_PARSE_ERROR" = "NONE" ]; then
|
|
CONTRACT_PARSE_ERROR="${candidate_field}_${PARSED_FIELD_ERROR}"
|
|
fi
|
|
done
|
|
|
|
if [ "$CONTRACT_PARSE_ERROR" != "NONE" ]; then
|
|
FINAL_RC=22
|
|
FINAL_RESULT="INCONCLUSIVE_S03H1_CONTRACT"
|
|
BLOCK_REASON="$CONTRACT_PARSE_ERROR"
|
|
return 0
|
|
fi
|
|
if [ "$PARSED_MEASUREMENT_ELIGIBILITY" != "NO" ]; then
|
|
FINAL_RC=22
|
|
FINAL_RESULT="INCONCLUSIVE_S03H1_CONTRACT"
|
|
BLOCK_REASON="ELIGIBILITY_CONTRACT_VIOLATION_${PARSED_MEASUREMENT_ELIGIBILITY}"
|
|
return 0
|
|
fi
|
|
if [ "$classify_invariance_status" != "PASS" ]; then
|
|
FINAL_RC=71
|
|
FINAL_RESULT="FAIL_PROTECTED_BASELINE_CHANGED"
|
|
BLOCK_REASON="PROTECTED_BASELINE_INVARIANCE_${classify_invariance_status}"
|
|
return 0
|
|
fi
|
|
if [ "$classify_csv_rc" -ne 0 ]; then
|
|
FINAL_RC=70
|
|
FINAL_RESULT="FAIL_DERIVED_CSV_EXPORT"
|
|
BLOCK_REASON="CSV_EXPORT_RC_${classify_csv_rc}"
|
|
return 0
|
|
fi
|
|
|
|
case "$classify_validator_rc" in
|
|
0|10|11)
|
|
;;
|
|
20|21)
|
|
FINAL_RC=20
|
|
FINAL_RESULT="S03H1_VALIDATION_INCONCLUSIVE"
|
|
BLOCK_REASON="VALIDATOR_RC_${classify_validator_rc}"
|
|
return 0
|
|
;;
|
|
*)
|
|
FINAL_RC=68
|
|
FINAL_RESULT="FAIL_VALIDATOR_EXIT"
|
|
BLOCK_REASON="UNRECOGNISED_VALIDATOR_RC_${classify_validator_rc}"
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
for candidate_status in \
|
|
"$PARSED_MODE_STATUS" \
|
|
"$PARSED_PROFILE_CONFIG_STATUS" \
|
|
"$PARSED_OBSERVABILITY_STATUS" \
|
|
"$PARSED_FUNCTIONAL_STATUS" \
|
|
"$PARSED_SEMANTIC_STATUS"
|
|
do
|
|
if [ "$candidate_status" != "PASS" ]; then
|
|
FINAL_RC=25
|
|
FINAL_RESULT="S03H1_CONTRACT_STATUS_NOT_PASS"
|
|
BLOCK_REASON="REQUIRED_STATUS_${candidate_status}"
|
|
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_TIMING_CONTRACT"
|
|
BLOCK_REASON="TIMING_STATUS_${PARSED_TIMING_STATUS}"
|
|
;;
|
|
esac
|
|
return 0
|
|
}
|
|
|
|
run_s03h1() {
|
|
duration="$1"
|
|
MODE="$2"
|
|
|
|
case "$MODE" in
|
|
TEST)
|
|
CANDIDATE_CONFIG="$TEST_CONFIG"
|
|
EXPECTED_CANDIDATE_CONFIG_SHA256="$EXPECTED_TEST_CONFIG_SHA256"
|
|
;;
|
|
DIAGNOSTIC)
|
|
CANDIDATE_CONFIG="$DIAGNOSTIC_CONFIG"
|
|
EXPECTED_CANDIDATE_CONFIG_SHA256="$EXPECTED_DIAGNOSTIC_CONFIG_SHA256"
|
|
;;
|
|
*)
|
|
printf "ERRORE: MODE non riconosciuto: %s\n" "$MODE" >&2
|
|
return 2
|
|
;;
|
|
esac
|
|
|
|
if [ ! -d "$SUITE" ]; then
|
|
printf "ERRORE: suite operativa assente: %s\n" "$SUITE" >&2
|
|
return 50
|
|
fi
|
|
if ! verify_candidate_components; then
|
|
printf "ERRORE: integrita' candidata non dimostrata.\n" >&2
|
|
return 51
|
|
fi
|
|
if ! verify_protected_baseline; then
|
|
printf "ERRORE: baseline protetta assente o con hash inatteso.\n" >&2
|
|
return 52
|
|
fi
|
|
|
|
WORK_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/s03h1_launcher.XXXXXX")" || return 53
|
|
trap 'rm -rf -- "$WORK_ROOT"' EXIT HUP INT TERM
|
|
GENERATED_CONFIG="$WORK_ROOT/generated_${MODE}.marte"
|
|
PATCHER_LOG="$WORK_ROOT/patcher.log"
|
|
PROTECTED_BEFORE="$WORK_ROOT/protected_baseline_before.sha256"
|
|
CAPTURE="$WORK_ROOT/runner_capture.log"
|
|
|
|
"$PATCHER" "$LIVE_S02_CONFIG" "$GENERATED_CONFIG" "$MODE" >"$PATCHER_LOG" 2>&1
|
|
PATCHER_RC=$?
|
|
if [ "$PATCHER_RC" -ne 0 ]; then
|
|
printf "ERRORE: patcher candidato fallito rc=%s\n" "$PATCHER_RC" >&2
|
|
cat -- "$PATCHER_LOG" >&2
|
|
return 54
|
|
fi
|
|
if ! cmp -s -- "$GENERATED_CONFIG" "$CANDIDATE_CONFIG"; then
|
|
printf "ERRORE: build candidato non coincide con config confezionata.\n" >&2
|
|
return 55
|
|
fi
|
|
|
|
write_protected_hashes "$PROTECTED_BEFORE" || return 56
|
|
|
|
if [ ! -f "$LIVE_PATHS" ]; then
|
|
printf "ERRORE: paths.sh assente: %s\n" "$LIVE_PATHS" >&2
|
|
return 57
|
|
fi
|
|
# shellcheck source=/dev/null
|
|
source "$LIVE_PATHS"
|
|
CONSTANT_GAM_LIB_DIR="$MARTE2_COMPONENTS_ROOT/Build/$MARTE_TARGET/Components/GAMs/ConstantGAM"
|
|
CONSTANT_GAM_LIB="$CONSTANT_GAM_LIB_DIR/ConstantGAM.so"
|
|
if [ ! -f "$CONSTANT_GAM_LIB" ]; then
|
|
printf "ERRORE: ConstantGAM assente: %s\n" "$CONSTANT_GAM_LIB" >&2
|
|
return 58
|
|
fi
|
|
case ":${LD_LIBRARY_PATH-}:" in
|
|
*":${CONSTANT_GAM_LIB_DIR}:"*) ;;
|
|
*)
|
|
if [ -n "${LD_LIBRARY_PATH-}" ]; then
|
|
LD_LIBRARY_PATH="${CONSTANT_GAM_LIB_DIR}:${LD_LIBRARY_PATH}"
|
|
else
|
|
LD_LIBRARY_PATH="$CONSTANT_GAM_LIB_DIR"
|
|
fi
|
|
;;
|
|
esac
|
|
export LD_LIBRARY_PATH
|
|
|
|
printf "============================================================\n"
|
|
printf "S03-H1 EXECUTION PROFILES - RUN CANDIDATA\n"
|
|
printf "============================================================\n"
|
|
printf "MODE=%s\n" "$MODE"
|
|
printf "DURATION=%s\n" "$duration"
|
|
printf "CURRENT_OPERATIONAL_BASELINE=S03_R3_INSTALLED\n"
|
|
printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"
|
|
|
|
"$RUNNER" \
|
|
"S03H1_${MODE}_launcher" \
|
|
"$CANDIDATE_CONFIG" \
|
|
"State1" \
|
|
"$duration" \
|
|
2>&1 | tee "$CAPTURE"
|
|
RUNNER_CODES=("${PIPESTATUS[@]}")
|
|
RUNNER_RC="${RUNNER_CODES[0]}"
|
|
CAPTURE_TEE_RC="${RUNNER_CODES[1]}"
|
|
if [ "$RUNNER_RC" -ne 0 ]; then
|
|
printf "ERRORE: common runner fallito rc=%s\n" "$RUNNER_RC" >&2
|
|
return 60
|
|
fi
|
|
if [ "$CAPTURE_TEE_RC" -ne 0 ]; then
|
|
printf "ERRORE: capture common runner fallita.\n" >&2
|
|
return 61
|
|
fi
|
|
|
|
RUN_DIR="$(sed -n 's/^RUN_DIR=//p' "$CAPTURE" | tail -n 1)"
|
|
if [ -z "$RUN_DIR" ] || [ ! -d "$RUN_DIR" ]; then
|
|
printf "ERRORE: RUN_DIR non individuata o assente: %s\n" "$RUN_DIR" >&2
|
|
return 62
|
|
fi
|
|
|
|
RUN_LOG="$RUN_DIR/run.log"
|
|
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/s03h1_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="$RUN_DIR/protected_baseline_after.sha256"
|
|
INVARIANCE_REPORT="$RUN_DIR/protected_baseline_invariance.txt"
|
|
|
|
cp -- "$PROTECTED_BEFORE" "$PROTECTED_BEFORE_RUN"
|
|
{
|
|
printf "SCENARIO=S03H1\n"
|
|
printf "MODE=%s\n" "$MODE"
|
|
printf "CANDIDATE_CONFIG_SHA256=%s\n" "$EXPECTED_CANDIDATE_CONFIG_SHA256"
|
|
printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"
|
|
} >"$MODE_FILE"
|
|
|
|
sha256sum -- \
|
|
"$MODE_FILE" \
|
|
"${BASH_SOURCE[0]}" \
|
|
"$PATCHER" \
|
|
"$VALIDATOR" \
|
|
"$CONFIG_VERIFIER" \
|
|
"$CSV_EXPORTER" \
|
|
"$LIVE_PARSER_S03" \
|
|
"$RUN_LOG" \
|
|
"$RUNNER_SUMMARY" \
|
|
"$OUTPUT_FILE" \
|
|
"$PROTECTED_BEFORE_RUN" \
|
|
"${PROTECTED_PATHS[@]}" \
|
|
>>"$RUN_HASHES"
|
|
|
|
S03_BASELINE_PARSER="$LIVE_PARSER_S03" \
|
|
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_RC=$?
|
|
|
|
write_protected_hashes "$PROTECTED_AFTER_RUN"
|
|
if cmp -s -- "$PROTECTED_BEFORE_RUN" "$PROTECTED_AFTER_RUN"; then
|
|
PROTECTED_BASELINE_INVARIANCE="PASS"
|
|
else
|
|
PROTECTED_BASELINE_INVARIANCE="FAIL"
|
|
fi
|
|
{
|
|
printf "PROTECTED_BASELINE_INVARIANCE=%s\n" "$PROTECTED_BASELINE_INVARIANCE"
|
|
printf "CURRENT_OPERATIONAL_BASELINE=S03_R3_INSTALLED\n"
|
|
printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"
|
|
} >"$INVARIANCE_REPORT"
|
|
|
|
for evidence_file in \
|
|
"$VALIDATION_LOG" \
|
|
"$CSV_REPORT" \
|
|
"$PROTECTED_AFTER_RUN" \
|
|
"$INVARIANCE_REPORT"
|
|
do
|
|
if [ -f "$evidence_file" ]; then
|
|
sha256sum -- "$evidence_file" >>"$RUN_HASHES"
|
|
fi
|
|
done
|
|
if [ -f "$CSV_FILE" ]; then
|
|
sha256sum -- "$CSV_FILE" >>"$RUN_HASHES"
|
|
fi
|
|
|
|
classify_s03h1_run \
|
|
"$VALIDATOR_RC" \
|
|
"$VALIDATION_TEE_RC" \
|
|
"$VALIDATION_LOG" \
|
|
"$CSV_RC" \
|
|
"$PROTECTED_BASELINE_INVARIANCE"
|
|
|
|
{
|
|
printf "============================================================\n"
|
|
printf "RIEPILOGO LAUNCHER S03-H1 CANDIDATO\n"
|
|
printf "============================================================\n"
|
|
printf "SCENARIO=S03H1\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_RC"
|
|
printf "CSV_STATUS=%s\n" "$( [ "$CSV_RC" -eq 0 ] && printf PASS || printf FAIL )"
|
|
printf "MODE_STATUS=%s\n" "$PARSED_MODE_STATUS"
|
|
printf "PROFILE_CONFIG_STATUS=%s\n" "$PARSED_PROFILE_CONFIG_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 "PROTECTED_BASELINE_INVARIANCE=%s\n" "$PROTECTED_BASELINE_INVARIANCE"
|
|
printf "BLOCK_REASON=%s\n" "$BLOCK_REASON"
|
|
printf "FINAL_RESULT=%s\n" "$FINAL_RESULT"
|
|
printf "FINAL_RC=%s\n" "$FINAL_RC"
|
|
printf "S03_H1_INSTALLATION_AUTHORIZED=NO\n"
|
|
printf "CURRENT_OPERATIONAL_BASELINE=S03_R3_INSTALLED\n"
|
|
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
|
|
else
|
|
sha256sum -- "$LAUNCHER_SUMMARY" >>"$RUN_HASHES"
|
|
fi
|
|
|
|
printf "RUN_DIR=%s\n" "$RUN_DIR"
|
|
printf "RISULTATO_FINALE=%s\n" "$FINAL_RESULT"
|
|
printf "FINAL_RC=%s\n" "$FINAL_RC"
|
|
|
|
rm -rf -- "$WORK_ROOT"
|
|
trap - EXIT HUP INT TERM
|
|
return "$FINAL_RC"
|
|
}
|
|
|
|
if [ "${S03H1_LAUNCHER_LIB_ONLY:-0}" = "1" ]; then
|
|
if [ "${BASH_SOURCE[0]}" != "$0" ]; then
|
|
return 0
|
|
fi
|
|
printf "ERRORE: S03H1_LAUNCHER_LIB_ONLY=1 e' ammesso solo con 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)
|
|
if [ "$1" != "S03H1" ] && [ "$1" != "s03h1" ]; then
|
|
print_usage >&2
|
|
exit 2
|
|
fi
|
|
if ! validate_duration "$2"; then
|
|
printf "ERRORE: durata non valida: %s\n" "$2" >&2
|
|
exit 2
|
|
fi
|
|
case "$3" in
|
|
TEST|DIAGNOSTIC) ;;
|
|
*)
|
|
printf "ERRORE: MODE non riconosciuto: %s\n" "$3" >&2
|
|
exit 2
|
|
;;
|
|
esac
|
|
run_s03h1 "$2" "$3"
|
|
exit $?
|
|
;;
|
|
*)
|
|
print_usage >&2
|
|
exit 2
|
|
;;
|
|
esac
|