475 lines
16 KiB
Bash
475 lines
16 KiB
Bash
#!/usr/bin/env bash
|
|
|
|
set -euo pipefail
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
COMPOSE_FILE="${COMPOSE_FILE:-${SCRIPT_DIR}/../docker-compose.yml}"
|
|
|
|
BASE_URL="${BASE_URL:-http://localhost:5270}"
|
|
RABBITMQ_MGMT_URL="${RABBITMQ_MGMT_URL:-http://localhost:15674}"
|
|
RABBITMQ_USER="${RABBITMQ_USER:-guest}"
|
|
RABBITMQ_PASS="${RABBITMQ_PASS:-guest}"
|
|
MINIO_ENDPOINT="${MINIO_ENDPOINT:-localhost:9005}"
|
|
MINIO_ACCESS_KEY="${MINIO_ACCESS_KEY:-minioadmin}"
|
|
MINIO_SECRET_KEY="${MINIO_SECRET_KEY:-minioadmin}"
|
|
MINIO_BUCKET="${MINIO_BUCKET:-vigilcare}"
|
|
|
|
PGHOST="${PGHOST:-localhost}"
|
|
PGPORT="${PGPORT:-5436}"
|
|
PGDATABASE="${PGDATABASE:-vigilcare}"
|
|
PGUSER="${PGUSER:-postgres}"
|
|
PGPASSWORD="${PGPASSWORD:-password}"
|
|
|
|
RELAY_WAIT_SECS="${RELAY_WAIT_SECS:-45}"
|
|
KAFKA_READY_WAIT_SECS="${KAFKA_READY_WAIT_SECS:-30}"
|
|
PAGING_PIPELINE_WAIT_SECS="${PAGING_PIPELINE_WAIT_SECS:-30}"
|
|
MINIO_WAIT_SECS="${MINIO_WAIT_SECS:-15}"
|
|
ACK_PIPELINE_WAIT_SECS="${ACK_PIPELINE_WAIT_SECS:-10}"
|
|
|
|
SCRIPT_RUN_ID="$(date -u +"%Y%m%d%H%M%S")"
|
|
RECORDED_AT="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
|
|
|
|
EXPECTED_QUEUES=(
|
|
"alerts.paging.queue"
|
|
"alerts.paging.dlq"
|
|
"alerts.escalation.queue"
|
|
"notifications.discharge.queue"
|
|
"notifications.appointment.queue"
|
|
)
|
|
|
|
TMP_FILES=()
|
|
|
|
cleanup() {
|
|
local f
|
|
for f in "${TMP_FILES[@]}"; do
|
|
rm -f "${f}" "${f}.status" 2>/dev/null || true
|
|
done
|
|
}
|
|
trap cleanup EXIT
|
|
|
|
if ! command -v curl >/dev/null 2>&1; then
|
|
echo "Missing dependency: curl"
|
|
exit 1
|
|
fi
|
|
|
|
if ! command -v jq >/dev/null 2>&1; then
|
|
echo "Missing dependency: jq"
|
|
exit 1
|
|
fi
|
|
|
|
if ! command -v docker >/dev/null 2>&1 || [[ ! -f "${COMPOSE_FILE}" ]]; then
|
|
echo "Missing dependency: docker compose (${COMPOSE_FILE})"
|
|
exit 1
|
|
fi
|
|
|
|
compose() {
|
|
docker compose -f "${COMPOSE_FILE}" "$@"
|
|
}
|
|
|
|
kafka_exec() {
|
|
compose exec -T kafka "$@"
|
|
}
|
|
|
|
psql_cmd() {
|
|
local sql="$1"
|
|
if command -v psql >/dev/null 2>&1; then
|
|
PGPASSWORD="${PGPASSWORD}" psql -h "${PGHOST}" -p "${PGPORT}" -U "${PGUSER}" -d "${PGDATABASE}" -tAc "${sql}"
|
|
else
|
|
compose exec -T postgres psql -U "${PGUSER}" -d "${PGDATABASE}" -tAc "${sql}"
|
|
fi
|
|
}
|
|
|
|
request() {
|
|
local method="$1"
|
|
local url="$2"
|
|
local body="${3:-}"
|
|
local tmp_body
|
|
tmp_body="$(mktemp)"
|
|
TMP_FILES+=("${tmp_body}")
|
|
local status
|
|
|
|
if [[ -n "${body}" ]]; then
|
|
status="$(curl -sS -o "${tmp_body}" -w "%{http_code}" -X "${method}" "${url}" \
|
|
-H "Content-Type: application/json" -d "${body}")"
|
|
else
|
|
status="$(curl -sS -o "${tmp_body}" -w "%{http_code}" -X "${method}" "${url}")"
|
|
fi
|
|
|
|
echo "${status}" > "${tmp_body}.status"
|
|
echo "${tmp_body}"
|
|
}
|
|
|
|
assert_status() {
|
|
local expected="$1"
|
|
local body_file="$2"
|
|
local status
|
|
status="$(cat "${body_file}.status")"
|
|
if [[ "${status}" != "${expected}" ]]; then
|
|
echo "Expected HTTP ${expected}, got ${status}"
|
|
echo "Response body:"
|
|
cat "${body_file}"
|
|
echo
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
rabbit_api() {
|
|
curl -sS -u "${RABBITMQ_USER}:${RABBITMQ_PASS}" "${RABBITMQ_MGMT_URL}/api/${1}"
|
|
}
|
|
|
|
queue_field() {
|
|
local queue="$1"
|
|
local field="$2"
|
|
rabbit_api "queues/%2F/${queue}" | jq -r ".${field} // 0"
|
|
}
|
|
|
|
wait_for_kafka() {
|
|
local elapsed=0
|
|
while (( elapsed < KAFKA_READY_WAIT_SECS )); do
|
|
if kafka_exec /opt/kafka/bin/kafka-broker-api-versions.sh --bootstrap-server localhost:9092 >/dev/null 2>&1; then
|
|
return 0
|
|
fi
|
|
sleep 2
|
|
elapsed=$((elapsed + 2))
|
|
done
|
|
echo "Kafka did not become ready within ${KAFKA_READY_WAIT_SECS}s"
|
|
return 1
|
|
}
|
|
|
|
wait_for_outbox_processed() {
|
|
local outbox_id="$1"
|
|
local elapsed=0
|
|
while (( elapsed < RELAY_WAIT_SECS )); do
|
|
local processed
|
|
processed="$(psql_cmd "SELECT processed_at IS NOT NULL FROM outbox_events WHERE id = '${outbox_id}'")"
|
|
if [[ "${processed}" == "t" ]]; then
|
|
return 0
|
|
fi
|
|
sleep 1
|
|
elapsed=$((elapsed + 1))
|
|
done
|
|
echo "Outbox row ${outbox_id} was not processed within ${RELAY_WAIT_SECS}s"
|
|
return 1
|
|
}
|
|
|
|
wait_for_alert_outbox_relayed() {
|
|
local encounter_id="$1"
|
|
local elapsed=0
|
|
while (( elapsed < RELAY_WAIT_SECS )); do
|
|
local outbox_id
|
|
outbox_id="$(psql_cmd "SELECT id FROM outbox_events WHERE topic = 'alert.generated' AND partition_key = '${encounter_id}' ORDER BY created_at DESC LIMIT 1")"
|
|
if [[ -n "${outbox_id}" ]]; then
|
|
local processed
|
|
processed="$(psql_cmd "SELECT processed_at IS NOT NULL FROM outbox_events WHERE id = '${outbox_id}'")"
|
|
if [[ "${processed}" == "t" ]]; then
|
|
return 0
|
|
fi
|
|
fi
|
|
sleep 1
|
|
elapsed=$((elapsed + 1))
|
|
done
|
|
echo "alert.generated outbox for encounter ${encounter_id} was not relayed within ${RELAY_WAIT_SECS}s"
|
|
return 1
|
|
}
|
|
|
|
wait_for_paging_activity() {
|
|
local elapsed=0
|
|
while (( elapsed < PAGING_PIPELINE_WAIT_SECS )); do
|
|
local unacked ready total
|
|
unacked="$(queue_field "alerts.paging.queue" "messages_unacknowledged")"
|
|
ready="$(queue_field "alerts.paging.queue" "messages_ready")"
|
|
total="$(queue_field "alerts.paging.queue" "messages")"
|
|
if [[ "${unacked}" -ge 1 || "${ready}" -ge 1 || "${total}" -ge 1 ]]; then
|
|
return 0
|
|
fi
|
|
sleep 1
|
|
elapsed=$((elapsed + 1))
|
|
done
|
|
echo "No paging activity on alerts.paging.queue within ${PAGING_PIPELINE_WAIT_SECS}s"
|
|
return 1
|
|
}
|
|
|
|
wait_for_alert_status() {
|
|
local alert_id="$1"
|
|
local expected="$2"
|
|
local timeout_secs="$3"
|
|
local elapsed=0
|
|
while (( elapsed < timeout_secs )); do
|
|
local status
|
|
status="$(psql_cmd "SELECT status FROM clinical_alerts WHERE id = '${alert_id}'")"
|
|
if [[ "${status}" == "${expected}" ]]; then
|
|
return 0
|
|
fi
|
|
sleep 1
|
|
elapsed=$((elapsed + 1))
|
|
done
|
|
local final
|
|
final="$(psql_cmd "SELECT status FROM clinical_alerts WHERE id = '${alert_id}'")"
|
|
echo "Alert ${alert_id} did not reach status ${expected} within ${timeout_secs}s (last status=${final:-unknown})"
|
|
return 1
|
|
}
|
|
|
|
minio_object_exists() {
|
|
local object_key="$1"
|
|
if command -v mc >/dev/null 2>&1; then
|
|
mc alias set local "http://${MINIO_ENDPOINT}" "${MINIO_ACCESS_KEY}" "${MINIO_SECRET_KEY}" --api S3v4 >/dev/null 2>&1 || true
|
|
mc stat "local/${MINIO_BUCKET}/${object_key}" >/dev/null 2>&1
|
|
return $?
|
|
fi
|
|
|
|
docker run --rm --network host --entrypoint /bin/sh minio/mc:latest \
|
|
-c "mc alias set local http://${MINIO_ENDPOINT} ${MINIO_ACCESS_KEY} ${MINIO_SECRET_KEY} >/dev/null 2>&1 && mc stat local/${MINIO_BUCKET}/${object_key}" \
|
|
>/dev/null 2>&1
|
|
}
|
|
|
|
create_patient() {
|
|
local payload='{"firstName":"Notify","lastName":"Verifier","dateOfBirth":"1972-03-18","gender":"Female"}'
|
|
local resp
|
|
resp="$(request POST "${BASE_URL}/api/v1/patients" "${payload}")"
|
|
assert_status "201" "${resp}"
|
|
jq -r '.data.id' "${resp}"
|
|
}
|
|
|
|
create_encounter() {
|
|
local patient_id="$1"
|
|
local suffix="$2"
|
|
local payload
|
|
payload="$(jq -nc \
|
|
--arg physician "Dr. Notify ${suffix}" \
|
|
'{encounterType:"Inpatient",department:"ICU",attendingPhysician:$physician}')"
|
|
local resp
|
|
resp="$(request POST "${BASE_URL}/api/v1/patients/${patient_id}/encounters" "${payload}")"
|
|
assert_status "201" "${resp}"
|
|
jq -r '.data.id' "${resp}"
|
|
}
|
|
|
|
ingest_critical_potassium() {
|
|
local encounter_id="$1"
|
|
local idempotency_key="$2"
|
|
local payload
|
|
payload="$(jq -nc \
|
|
--arg recordedAt "${RECORDED_AT}" \
|
|
--arg key "${idempotency_key}" \
|
|
'{observations:[{observationCode:"POTASSIUM_MEQ_L",value:2.1,unit:"mEq/L",source:"LAB",recordedAt:$recordedAt,idempotencyKey:$key}]}')"
|
|
local resp
|
|
resp="$(request POST "${BASE_URL}/api/v1/encounters/${encounter_id}/observations" "${payload}")"
|
|
assert_status "201" "${resp}"
|
|
if [[ "$(jq -r '.data.alertGenerated' "${resp}")" != "true" ]]; then
|
|
echo "Expected critical potassium ingest to generate an alert"
|
|
exit 1
|
|
fi
|
|
jq -r '.data.alertId' "${resp}"
|
|
}
|
|
|
|
TOTAL_STEPS=8
|
|
|
|
echo "Running RabbitMQ + MinIO notification pipeline verification against ${BASE_URL}"
|
|
echo "Script run id: ${SCRIPT_RUN_ID}"
|
|
|
|
echo ""
|
|
echo "[0/${TOTAL_STEPS}] Preflight — API, Postgres, Kafka, RabbitMQ, and MinIO reachable"
|
|
preflight_status="$(curl -sS -o /dev/null -w "%{http_code}" "${BASE_URL}/api/v1/alert-thresholds" || true)"
|
|
if [[ "${preflight_status}" != "200" ]]; then
|
|
echo "API not reachable at ${BASE_URL} (HTTP ${preflight_status})."
|
|
echo "Start the API with: dotnet run --project VigilCareClinicalAPI"
|
|
exit 1
|
|
fi
|
|
|
|
if ! psql_cmd "SELECT 1" >/dev/null 2>&1; then
|
|
echo "Postgres not reachable on ${PGHOST}:${PGPORT}."
|
|
echo "Start the stack with: docker compose up -d"
|
|
exit 1
|
|
fi
|
|
|
|
if ! wait_for_kafka; then
|
|
exit 1
|
|
fi
|
|
|
|
rabbit_health="$(rabbit_api "health/checks/alarms" 2>/dev/null | jq -r '.status // empty' || true)"
|
|
if [[ -z "${rabbit_health}" ]]; then
|
|
echo "RabbitMQ management API not reachable at ${RABBITMQ_MGMT_URL}."
|
|
echo "Start RabbitMQ with: docker compose up -d rabbitmq"
|
|
exit 1
|
|
fi
|
|
|
|
if ! curl -sS -o /dev/null -w "%{http_code}" "http://${MINIO_ENDPOINT}/minio/health/live" | grep -q '^200$'; then
|
|
echo "MinIO not reachable at http://${MINIO_ENDPOINT}."
|
|
echo "Start MinIO with: docker compose up -d minio"
|
|
exit 1
|
|
fi
|
|
echo "OK: API, Postgres, Kafka, RabbitMQ, and MinIO are up"
|
|
|
|
echo ""
|
|
echo "[1/${TOTAL_STEPS}] Verifying RabbitMQ topology (exchange, five queues, DLQ arguments)"
|
|
exchange_name="$(rabbit_api "exchanges/%2F/clinical.notifications.exchange" | jq -r '.name // empty')"
|
|
if [[ "${exchange_name}" != "clinical.notifications.exchange" ]]; then
|
|
echo "Exchange clinical.notifications.exchange not found. Start the API so RabbitMqTopologyProvisioner runs."
|
|
exit 1
|
|
fi
|
|
|
|
for queue in "${EXPECTED_QUEUES[@]}"; do
|
|
queue_name="$(rabbit_api "queues/%2F/${queue}" | jq -r '.name // empty')"
|
|
if [[ "${queue_name}" != "${queue}" ]]; then
|
|
echo "Queue ${queue} not found (got '${queue_name}')."
|
|
exit 1
|
|
fi
|
|
done
|
|
|
|
dlq_ttl_ms="$(rabbit_api "queues/%2F/alerts.paging.dlq" | jq -r '.arguments["x-message-ttl"] // empty')"
|
|
dlq_dlx="$(rabbit_api "queues/%2F/alerts.paging.dlq" | jq -r '.arguments["x-dead-letter-exchange"] // empty')"
|
|
dlq_dlk="$(rabbit_api "queues/%2F/alerts.paging.dlq" | jq -r '.arguments["x-dead-letter-routing-key"] // empty')"
|
|
paging_dlk="$(rabbit_api "queues/%2F/alerts.paging.queue" | jq -r '.arguments["x-dead-letter-routing-key"] // empty')"
|
|
|
|
if [[ -z "${dlq_ttl_ms}" ]]; then
|
|
echo "alerts.paging.dlq is missing x-message-ttl"
|
|
exit 1
|
|
fi
|
|
if [[ "${dlq_dlx}" != "clinical.notifications.exchange" ]]; then
|
|
echo "Expected DLQ x-dead-letter-exchange=clinical.notifications.exchange, got '${dlq_dlx}'"
|
|
exit 1
|
|
fi
|
|
if [[ "${dlq_dlk}" != "alerts.escalation" ]]; then
|
|
echo "Expected DLQ x-dead-letter-routing-key=alerts.escalation, got '${dlq_dlk}'"
|
|
exit 1
|
|
fi
|
|
if [[ "${paging_dlk}" != "alerts.paging.dlq" ]]; then
|
|
echo "Expected paging queue DLK=alerts.paging.dlq, got '${paging_dlk}'"
|
|
exit 1
|
|
fi
|
|
|
|
ttl_sec=$(( dlq_ttl_ms / 1000 ))
|
|
ESCALATION_WAIT_SECS="${ESCALATION_WAIT_SECS:-$(( ttl_sec * 2 + 25 ))}"
|
|
echo "OK: exchange + 5 queues provisioned; DLQ TTL=${dlq_ttl_ms}ms (escalation wait budget=${ESCALATION_WAIT_SECS}s)"
|
|
|
|
echo ""
|
|
echo "[2/${TOTAL_STEPS}] Verifying non-alert observation does not enqueue paging jobs"
|
|
patient_no_page="$(create_patient)"
|
|
encounter_no_page="$(create_encounter "${patient_no_page}" "NoPage")"
|
|
|
|
paging_before="$(queue_field "alerts.paging.queue" "messages")"
|
|
normal_payload="$(jq -nc \
|
|
--arg recordedAt "${RECORDED_AT}" \
|
|
--arg key "notify-normal-${SCRIPT_RUN_ID}" \
|
|
'{observations:[{observationCode:"POTASSIUM_MEQ_L",value:3.8,unit:"mEq/L",source:"LAB",recordedAt:$recordedAt,idempotencyKey:$key}]}')"
|
|
resp="$(request POST "${BASE_URL}/api/v1/encounters/${encounter_no_page}/observations" "${normal_payload}")"
|
|
assert_status "201" "${resp}"
|
|
if [[ "$(jq -r '.data.alertGenerated' "${resp}")" != "false" ]]; then
|
|
echo "Expected normal potassium ingest to skip alert generation"
|
|
exit 1
|
|
fi
|
|
|
|
sleep 3
|
|
paging_after="$(queue_field "alerts.paging.queue" "messages")"
|
|
if [[ "${paging_after}" -gt "${paging_before}" ]]; then
|
|
echo "Paging queue grew after non-alert ingest (${paging_before} -> ${paging_after})"
|
|
exit 1
|
|
fi
|
|
echo "OK: normal observation produced no paging queue traffic"
|
|
|
|
echo ""
|
|
echo "[3/${TOTAL_STEPS}] Verifying critical alert reaches alerts.paging.queue via Kafka bridge"
|
|
patient_page="$(create_patient)"
|
|
encounter_page="$(create_encounter "${patient_page}" "Page")"
|
|
alert_page_id="$(ingest_critical_potassium "${encounter_page}" "notify-critical-page-${SCRIPT_RUN_ID}")"
|
|
|
|
if ! wait_for_alert_outbox_relayed "${encounter_page}"; then
|
|
exit 1
|
|
fi
|
|
if ! wait_for_paging_activity; then
|
|
echo "Hint: confirm NotificationPublisherService is running and alert.generated severity is Critical."
|
|
exit 1
|
|
fi
|
|
echo "OK: critical alert ${alert_page_id} reached alerts.paging.queue (worker holding or ready message present)"
|
|
|
|
echo ""
|
|
echo "[4/${TOTAL_STEPS}] Verifying acknowledge-before-timeout path (no escalation)"
|
|
ack_payload='{"clinicianId":"DR-SCRIPT","note":"Acknowledged from notification verification script."}'
|
|
resp="$(request POST "${BASE_URL}/api/v1/alerts/${alert_page_id}/acknowledge" "${ack_payload}")"
|
|
assert_status "200" "${resp}"
|
|
|
|
sleep "${ACK_PIPELINE_WAIT_SECS}"
|
|
if ! wait_for_alert_status "${alert_page_id}" "ACKNOWLEDGED" 5; then
|
|
exit 1
|
|
fi
|
|
echo "OK: alert ${alert_page_id} is ACKNOWLEDGED (not escalated)"
|
|
|
|
echo ""
|
|
echo "[5/${TOTAL_STEPS}] Verifying full DLQ escalation path (unacknowledged critical alert)"
|
|
patient_escalate="$(create_patient)"
|
|
encounter_escalate="$(create_encounter "${patient_escalate}" "Escalate")"
|
|
alert_escalate_id="$(ingest_critical_potassium "${encounter_escalate}" "notify-critical-escalate-${SCRIPT_RUN_ID}")"
|
|
|
|
if ! wait_for_alert_outbox_relayed "${encounter_escalate}"; then
|
|
exit 1
|
|
fi
|
|
if ! wait_for_paging_activity; then
|
|
exit 1
|
|
fi
|
|
|
|
echo "Waiting up to ${ESCALATION_WAIT_SECS}s for paging timeout + DLQ TTL + escalation worker..."
|
|
if ! wait_for_alert_status "${alert_escalate_id}" "ESCALATED" "${ESCALATION_WAIT_SECS}"; then
|
|
echo "Hint: default DLQ TTL is 300000ms (~10 min total). Set PagingAckTimeoutMs=5000 in appsettings.json and restart the API for a faster run, or raise ESCALATION_WAIT_SECS."
|
|
exit 1
|
|
fi
|
|
echo "OK: alert ${alert_escalate_id} escalated to ESCALATED in PostgreSQL"
|
|
|
|
echo ""
|
|
echo "[6/${TOTAL_STEPS}] Verifying discharge summary upload to MinIO"
|
|
patient_discharge="$(create_patient)"
|
|
encounter_discharge="$(create_encounter "${patient_discharge}" "Discharge")"
|
|
discharge_payload='{"status":"Discharged"}'
|
|
resp="$(request PATCH "${BASE_URL}/api/v1/encounters/${encounter_discharge}/status" "${discharge_payload}")"
|
|
assert_status "200" "${resp}"
|
|
|
|
discharge_outbox_id="$(psql_cmd "SELECT id FROM outbox_events WHERE topic = 'encounter.status.changed' AND partition_key = '${encounter_discharge}' ORDER BY created_at DESC LIMIT 1")"
|
|
if [[ -z "${discharge_outbox_id}" ]]; then
|
|
echo "No encounter.status.changed outbox row for encounter ${encounter_discharge}"
|
|
exit 1
|
|
fi
|
|
wait_for_outbox_processed "${discharge_outbox_id}"
|
|
|
|
object_key="discharge-summaries/${encounter_discharge}/summary.pdf"
|
|
elapsed=0
|
|
while (( elapsed < MINIO_WAIT_SECS )); do
|
|
if minio_object_exists "${object_key}"; then
|
|
break
|
|
fi
|
|
sleep 1
|
|
elapsed=$((elapsed + 1))
|
|
done
|
|
|
|
if ! minio_object_exists "${object_key}"; then
|
|
echo "MinIO object not found: ${MINIO_BUCKET}/${object_key}"
|
|
echo "Hint: confirm DischargeSummaryWorkerService is running and notifications.discharge.queue is draining."
|
|
exit 1
|
|
fi
|
|
echo "OK: discharge summary object exists at ${MINIO_BUCKET}/${object_key}"
|
|
|
|
echo ""
|
|
echo "[7/${TOTAL_STEPS}] Verifying discharge queue drained after summary upload"
|
|
elapsed=0
|
|
while (( elapsed < MINIO_WAIT_SECS )); do
|
|
discharge_ready="$(queue_field "notifications.discharge.queue" "messages_ready")"
|
|
discharge_unacked="$(queue_field "notifications.discharge.queue" "messages_unacknowledged")"
|
|
if [[ "${discharge_ready}" == "0" && "${discharge_unacked}" == "0" ]]; then
|
|
break
|
|
fi
|
|
sleep 1
|
|
elapsed=$((elapsed + 1))
|
|
done
|
|
|
|
discharge_ready="$(queue_field "notifications.discharge.queue" "messages_ready")"
|
|
discharge_unacked="$(queue_field "notifications.discharge.queue" "messages_unacknowledged")"
|
|
if [[ "${discharge_ready}" != "0" || "${discharge_unacked}" != "0" ]]; then
|
|
echo "Expected notifications.discharge.queue to be empty (ready=${discharge_ready}, unacked=${discharge_unacked})"
|
|
exit 1
|
|
fi
|
|
echo "OK: notifications.discharge.queue is drained"
|
|
|
|
echo ""
|
|
echo "All ${TOTAL_STEPS} notification pipeline checks passed."
|
|
echo ""
|
|
echo "Prerequisites: docker compose up -d && dotnet run --project VigilCareClinicalAPI"
|
|
echo "Optional: set PagingAckTimeoutMs=5000 in appsettings.json (restart API) for ~15s escalation instead of ~10 min."
|
|
echo "Optional: ESCALATION_WAIT_SECS=330 when using the production 300000ms DLQ TTL."
|