Skip to content

stop_ems.sh

#!/usr/bin/env bash
# stop_ems.sh
# Stop the complete EMS process set started by start_ems_client_in_docker.sh.
set -Eeuo pipefail

GREEN="\033[1;32m"
RED="\033[1;31m"
YELLOW="\033[1;33m"
NC="\033[0m"

TERM_WAIT="${TERM_WAIT:-5}"

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# ------------------------------------------------------------------
# EMS API token
# Source: emsConfig/ems/ems_api_config.json
# The JSON may contain either:
#   "bearer_token": "Bearer <token>"
# or:
#   "bearer_token": "<token>"
#
# ems_settings_api.py adds "Bearer " itself, so normalize to raw token.
# ------------------------------------------------------------------
EMS_API_CONFIG_FILE="${EMS_API_CONFIG_FILE:-$SCRIPT_DIR/emsConfig/ems/ems_api_config.json}"

load_ems_api_token() {
    if [[ ! -f "$EMS_API_CONFIG_FILE" ]]; then
        echo -e "${RED:-}[ERROR] EMS API config not found: $EMS_API_CONFIG_FILE${NC:-}" >&2
        return 1
    fi

    local token
    token="$(
        python3 - "$EMS_API_CONFIG_FILE" <<'PY'
import json
import sys

path = sys.argv[1]

try:
    with open(path, "r", encoding="utf-8") as f:
        cfg = json.load(f)
except Exception as exc:
    print(f"ERROR: unable to read JSON: {exc}", file=sys.stderr)
    raise SystemExit(2)

token = str(
    cfg.get("ems_control_json", {}).get("bearer_token", "")
).strip()

if token.lower().startswith("bearer "):
    token = token[7:].strip()

if not token:
    print(
        "ERROR: ems_control_json.bearer_token is missing or empty",
        file=sys.stderr,
    )
    raise SystemExit(3)

print(token)
PY
    )" || return 1

    export EMS_SETTINGS_API_TOKEN="$token"
    export EMS_HARDWARE_BEARER_TOKEN="$token"

    echo -e "${GREEN:-}[OK] EMS API token loaded from $EMS_API_CONFIG_FILE${NC:-}"
}


print_help() {
    cat <<'EOF'
Usage:
  ./stop_ems.sh [OPTION]

Options:
  --all        Stop EMS supervisor and all EMS child processes (default)
  --clients    Same as --all; kept for compatibility
  --status     Show EMS process status without stopping
  -h, --help   Show this help

Description:
  Stops the EMS processes that are started by
  start_ems_client_in_docker.sh:

    ems_settings_api.py server
    ems_settings_api.py poll
    file_sync.py
    folder_sync.py
    folder_cleaner.py
    pcs_client_save_data_v20_ES100CX12S.py --pcs auto
    'gridMeter_client_save_data_v13.py'
    'solarMeter_client_save_data_v13.py'
    ems_main.py --hz 0

  SIGTERM is attempted first. SIGKILL is used only for processes
  that remain alive after the grace period.

Examples:
  ./stop_ems.sh
  ./stop_ems.sh --clients
  ./stop_ems.sh --status
EOF
}

# Exact process patterns corresponding to start_ems_client_in_docker.sh.
PATTERNS=(
    '[e]ms_settings_api\.py server'
    '[e]ms_settings_api\.py poll'
    '[f]ile_sync\.py'
    '[f]older_sync\.py'
    '[f]older_cleaner\.py'
    '[p]cs_client_save_data_v20_ES100CX12S\.py'
    '[g]ridMeter_client_save_data_v13\.py'
    '[s]olarMeter_client_save_data_v13\.py'
    '[e]ms_main\.py'
)

SUPERVISOR_PATTERN='[s]tart_ems_client_in_docker\.sh'

get_pids() {
    local pattern="$1"
    pgrep -f "$pattern" 2>/dev/null || true
}

show_status() {
    echo -e "${YELLOW}[INFO] EMS process status:${NC}"
    local found=0

    local pids
    pids="$(get_pids "$SUPERVISOR_PATTERN")"
    if [[ -n "$pids" ]]; then
        ps -fp $pids 2>/dev/null || true
        found=1
    fi

    for pattern in "${PATTERNS[@]}"; do
        pids="$(get_pids "$pattern")"
        if [[ -n "$pids" ]]; then
            ps -fp $pids 2>/dev/null || true
            found=1
        fi
    done

    if [[ "$found" -eq 0 ]]; then
        echo -e "${GREEN}[OK] No EMS processes are running.${NC}"
    fi
}

stop_pattern() {
    local label="$1"
    local pattern="$2"
    local pids

    pids="$(get_pids "$pattern")"

    if [[ -z "$pids" ]]; then
        echo -e "${YELLOW}[SKIP] $label is not running.${NC}"
        return 0
    fi

    echo -e "${YELLOW}[INFO] Stopping $label (PID(s): $(echo "$pids" | tr '\n' ' '))${NC}"

    # shellcheck disable=SC2086
    kill -TERM $pids 2>/dev/null || true

    local i
    for ((i=0; i<TERM_WAIT*2; i++)); do
        sleep 0.5
        pids="$(get_pids "$pattern")"
        [[ -z "$pids" ]] && break
    done

    pids="$(get_pids "$pattern")"
    if [[ -n "$pids" ]]; then
        echo -e "${YELLOW}[WARN] $label did not stop gracefully; sending SIGKILL.${NC}"
        # shellcheck disable=SC2086
        kill -KILL $pids 2>/dev/null || true
        sleep 0.3
    fi

    pids="$(get_pids "$pattern")"
    if [[ -n "$pids" ]]; then
        echo -e "${RED}[ERROR] Could not stop $label. Remaining PID(s): $(echo "$pids" | tr '\n' ' ')${NC}"
        return 1
    fi

    echo -e "${GREEN}[OK] $label stopped.${NC}"
}

case "${1:---all}" in
    --all|--clients)
        ;;
    --status)
        show_status
        exit 0
        ;;
    -h|--help)
        print_help
        exit 0
        ;;
    *)
        echo -e "${RED}[ERROR] Unknown option: $1${NC}"
        print_help
        exit 1
        ;;
esac

load_ems_api_token

echo -e "${YELLOW}[INFO] Stopping EMS stack...${NC}"

errors=0

# Stop supervisor first. Its SIGTERM trap should terminate all child PIDs cleanly.
stop_pattern "EMS supervisor" "$SUPERVISOR_PATTERN" || errors=$((errors + 1))

# Cleanup any orphaned EMS children if the supervisor was absent or a child survived.
LABELS=(
    "EMS settings API server"
    "EMS settings poll"
    "EMS control-setting sync"
    "EMS last-value folder sync"
    "EMS folder cleaner"
    "PCS client"
    "Grid meter client"
    "Solar meter client"
    "EMS main"
)

for i in "${!PATTERNS[@]}"; do
    stop_pattern "${LABELS[$i]}" "${PATTERNS[$i]}" || errors=$((errors + 1))
done

echo
if [[ "$errors" -eq 0 ]]; then
    echo -e "${GREEN}[OK] EMS stopped successfully.${NC}"
    exit 0
else
    echo -e "${RED}[ERROR] EMS stop completed with $errors error(s).${NC}"
    exit 1
fi