vmess-domain-rotator/scripts/router_local_update.sh

#!/bin/sh
set -eu

timestamp() {
  date '+%Y-%m-%d %H:%M:%S'
}

log() {
  printf '[%s] %s\n' "$(timestamp)" "$*"
}

log_err() {
  printf '[%s] %s\n' "$(timestamp)" "$*" >&2
}

SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
APP_DIR=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
CONFIG_PATH=${1:-"$APP_DIR/config_router.conf"}

if [ ! -r "$CONFIG_PATH" ]; then
  log_err "[router-local] config not found: $CONFIG_PATH"
  exit 1
fi

# shellcheck disable=SC1090
. "$CONFIG_PATH"

CFST_WORK_DIR=${CFST_WORK_DIR:-"$APP_DIR/cfst"}
CFST_BIN=${CFST_BIN:-"./cfst"}
CFST_IP_FILE=${CFST_IP_FILE:-"ip.txt"}
CFST_RESULT_FILE=${CFST_RESULT_FILE:-"result.csv"}
CFST_DISPLAY_COUNT=${CFST_DISPLAY_COUNT:-10}
CFST_THREADS=${CFST_THREADS:-}
CFST_TEST_COUNT=${CFST_TEST_COUNT:-}
CFST_DOWNLOAD_COUNT=${CFST_DOWNLOAD_COUNT:-}
CFST_DOWNLOAD_TIME=${CFST_DOWNLOAD_TIME:-}
CFST_PORT=${CFST_PORT:-443}
CFST_URL=${CFST_URL:-}
CFST_HTTPING=${CFST_HTTPING:-0}
CFST_HTTPING_CODE=${CFST_HTTPING_CODE:-}
CFST_CFCOLO=${CFST_CFCOLO:-}
CFST_LATENCY_LIMIT=${CFST_LATENCY_LIMIT:-}
CFST_LATENCY_LOWER=${CFST_LATENCY_LOWER:-}
CFST_LOSS_LIMIT=${CFST_LOSS_LIMIT:-}
CFST_SPEED_LIMIT=${CFST_SPEED_LIMIT:-}
CFST_DISABLE_DOWNLOAD=${CFST_DISABLE_DOWNLOAD:-0}
CFST_ALL_IP=${CFST_ALL_IP:-0}
CFST_DEBUG=${CFST_DEBUG:-0}
CFST_SKIP_RUN=${CFST_SKIP_RUN:-0}
CFST_QUIET_LOG=${CFST_QUIET_LOG:-1}
CFST_SHOW_LOG_ON_TTY=${CFST_SHOW_LOG_ON_TTY:-1}

TOP_N=${TOP_N:-3}
RUNTIME_DIR=${RUNTIME_DIR:-"$APP_DIR/cfip_runtime"}
VALUE_TEXT_FILE=${VALUE_TEXT_FILE:-"current_ip.txt"}
VALUE_JSON_FILE=${VALUE_JSON_FILE:-"current_ip.json"}
STATE_FILE=${STATE_FILE:-"state.json"}
EXPORT_VARS_FILE=${EXPORT_VARS_FILE:-"substore_vars.json"}
VALUE_JSON_KEY=${VALUE_JSON_KEY:-ip}
STATE_LAST_GOOD_KEY=${STATE_LAST_GOOD_KEY:-last_good_ip}
EXPORT_VALUE_KEY=${EXPORT_VALUE_KEY:-AUTO_CFIP}

resolve_path() {
  _p="$1"
  _base_dir="$2"
  case "$_p" in
    /*) printf '%s\n' "$_p" ;;
    *) printf '%s/%s\n' "$_base_dir" "$_p" ;;
  esac
}

CURRENT_TEXT_PATH=$(resolve_path "$VALUE_TEXT_FILE" "$RUNTIME_DIR")
CURRENT_JSON_PATH=$(resolve_path "$VALUE_JSON_FILE" "$RUNTIME_DIR")
STATE_PATH=$(resolve_path "$STATE_FILE" "$RUNTIME_DIR")
EXPORT_VARS_PATH=$(resolve_path "$EXPORT_VARS_FILE" "$RUNTIME_DIR")
INDEX_PATH="$RUNTIME_DIR/index.html"
RESULT_PATH=$(resolve_path "$CFST_RESULT_FILE" "$CFST_WORK_DIR")
UPDATED_AT=$(date -u +"%Y-%m-%dT%H:%M:%SZ")

mkdir -p "$RUNTIME_DIR"

json_get_string() {
  key="$1"
  file="$2"
  if [ ! -f "$file" ]; then
    return 0
  fi
  sed -n "s/.*\"$key\":[[:space:]]*\"\([^\"]*\)\".*/\1/p" "$file" | head -n 1
}

json_escape() {
  printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/	/\\t/g' | tr -d '\n\r'
}

build_top_candidates_json() {
  awk -F',' -v top_n="$TOP_N" '
    function trim(v) {
      gsub(/\r/, "", v)
      sub(/^[[:space:]]+/, "", v)
      sub(/[[:space:]]+$/, "", v)
      return v
    }
    function esc(v) {
      gsub(/\\/,"\\\\",v)
      gsub(/"/,"\\\"",v)
      return v
    }
    NR == 1 { next }
    count >= top_n { exit }
    NF < 1 { next }
    { if (trim($1) == "") next }
    {
      ip = esc(trim($1))
      sent = esc(trim($2))
      received = esc(trim($3))
      loss = esc(trim($4))
      latency = esc(trim($5))
      speed = esc(trim($6))
      region = esc(trim($7))
      if (count > 0) {
        printf(",")
      }
      printf("{\"domain\":\"%s\",\"ip\":\"%s\",\"source_type\":\"cfst_local_busybox\",\"sent\":\"%s\",\"received\":\"%s\",\"loss_rate\":\"%s\",\"avg_latency\":\"%s\",\"download_speed\":\"%s\",\"region\":\"%s\",\"location_country\":\"\",\"location_city\":\"\",\"host_provider\":\"\",\"score_value\":null,\"scores\":[],\"created_raw\":\"\"}", ip, ip, sent, received, loss, latency, speed, region)
      count++
    }
    END {
      if (count == 0) {
        printf("")
      }
    }
  ' "$RESULT_PATH"
}

atomic_write_file() {
  _dest="$1"
  _tmp="${_dest}.tmp.$$"
  cat > "$_tmp" && mv -f "$_tmp" "$_dest"
}

write_text_value() {
  selected_ip="$1"
  _tmp_txt="${CURRENT_TEXT_PATH}.tmp.$$"
  printf '%s\n' "$selected_ip" > "$_tmp_txt" && mv -f "$_tmp_txt" "$CURRENT_TEXT_PATH"
  rm -f "$INDEX_PATH"
  cp "$CURRENT_TEXT_PATH" "$INDEX_PATH"
}

write_success_outputs() {
  selected_ip="$1"
  top_candidates_json="$2"
  source_count="$3"

  escaped_ip=$(json_escape "$selected_ip")
  write_text_value "$selected_ip"
  atomic_write_file "$CURRENT_JSON_PATH" <<EOF
{
  "$VALUE_JSON_KEY": "$escaped_ip",
  "updated_at": "$UPDATED_AT",
  "status": "ok",
  "source_type": "cfst_local_busybox",
  "source_count": $source_count,
  "checked_count": 0,
  "top_candidates": [${top_candidates_json}]
}
EOF

  if [ "$selected_ip" != "${LAST_GOOD_IP:-}" ] || [ ! -f "$STATE_PATH" ] || [ "${LAST_STATE_STATUS:-}" != "ok" ]; then
    atomic_write_file "$STATE_PATH" <<EOF
{
  "updated_at": "$UPDATED_AT",
  "$STATE_LAST_GOOD_KEY": "$escaped_ip",
  "status": "ok",
  "source_count": $source_count,
  "checked_count": 0,
  "source_type": "cfst_local_busybox"
}
EOF
  fi

  atomic_write_file "$EXPORT_VARS_PATH" <<EOF
{
  "$EXPORT_VALUE_KEY": "$escaped_ip",
  "UPDATED_AT": "$UPDATED_AT",
  "STATUS": "ok"
}
EOF
}

write_error_with_fallback() {
  last_good_ip="$1"
  error_message="$2"
  escaped_ip=$(json_escape "$last_good_ip")
  escaped_error=$(json_escape "$error_message")

  write_text_value "$last_good_ip"
  atomic_write_file "$CURRENT_JSON_PATH" <<EOF
{
  "$VALUE_JSON_KEY": "$escaped_ip",
  "updated_at": "$UPDATED_AT",
  "status": "error_use_last_good",
  "error": "$escaped_error",
  "source_type": "cfst_local_busybox"
}
EOF

  if [ "$last_good_ip" != "${LAST_GOOD_IP:-}" ] || [ ! -f "$STATE_PATH" ]; then
    atomic_write_file "$STATE_PATH" <<EOF
{
  "updated_at": "$UPDATED_AT",
  "$STATE_LAST_GOOD_KEY": "$escaped_ip",
  "status": "error",
  "error": "$escaped_error",
  "source_type": "cfst_local_busybox"
}
EOF
  fi

  atomic_write_file "$EXPORT_VARS_PATH" <<EOF
{
  "$EXPORT_VALUE_KEY": "$escaped_ip",
  "UPDATED_AT": "$UPDATED_AT",
  "STATUS": "error_use_last_good"
}
EOF
}

run_cfst() (
  cd "$CFST_WORK_DIR"
  set -- "$CFST_BIN" -f "$CFST_IP_FILE" -o "$CFST_RESULT_FILE" -p "$CFST_DISPLAY_COUNT" -tp "$CFST_PORT"

  if [ -n "$CFST_THREADS" ]; then
    set -- "$@" -n "$CFST_THREADS"
  fi
  if [ -n "$CFST_TEST_COUNT" ]; then
    set -- "$@" -t "$CFST_TEST_COUNT"
  fi
  if [ -n "$CFST_DOWNLOAD_COUNT" ]; then
    set -- "$@" -dn "$CFST_DOWNLOAD_COUNT"
  fi
  if [ -n "$CFST_DOWNLOAD_TIME" ]; then
    set -- "$@" -dt "$CFST_DOWNLOAD_TIME"
  fi
  if [ -n "$CFST_URL" ]; then
    set -- "$@" -url "$CFST_URL"
  fi
  if [ "$CFST_HTTPING" = "1" ]; then
    set -- "$@" -httping
  fi
  if [ -n "$CFST_HTTPING_CODE" ]; then
    set -- "$@" -httping-code "$CFST_HTTPING_CODE"
  fi
  if [ -n "$CFST_CFCOLO" ]; then
    set -- "$@" -cfcolo "$CFST_CFCOLO"
  fi
  if [ -n "$CFST_LATENCY_LIMIT" ]; then
    set -- "$@" -tl "$CFST_LATENCY_LIMIT"
  fi
  if [ -n "$CFST_LATENCY_LOWER" ]; then
    set -- "$@" -tll "$CFST_LATENCY_LOWER"
  fi
  if [ -n "$CFST_LOSS_LIMIT" ]; then
    set -- "$@" -tlr "$CFST_LOSS_LIMIT"
  fi
  if [ -n "$CFST_SPEED_LIMIT" ]; then
    set -- "$@" -sl "$CFST_SPEED_LIMIT"
  fi
  if [ "$CFST_DISABLE_DOWNLOAD" = "1" ]; then
    set -- "$@" -dd
  fi
  if [ "$CFST_ALL_IP" = "1" ]; then
    set -- "$@" -allip
  fi
  if [ "$CFST_DEBUG" = "1" ]; then
    set -- "$@" -debug
  fi

  # Show cfst live logs for manual interactive runs, keep quiet for redirected/background runs.
  is_interactive_tty=0
  if [ "$CFST_SHOW_LOG_ON_TTY" = "1" ] && [ -t 1 ]; then
    is_interactive_tty=1
  fi

  if [ "$CFST_QUIET_LOG" = "1" ] && [ "$CFST_DEBUG" != "1" ] && [ "$is_interactive_tty" != "1" ]; then
    "$@" >/dev/null 2>&1
  else
    "$@"
  fi
)

log_update_summary() {
  selected_ip="$1"
  source_count="$2"
  log "[router-local] update_at=$UPDATED_AT selected_ip=$selected_ip candidates=$source_count"
  awk -F',' -v top_n="$TOP_N" '
    function trim(v) {
      gsub(/\r/, "", v)
      sub(/^[[:space:]]+/, "", v)
      sub(/[[:space:]]+$/, "", v)
      return v
    }
    NR == 1 { next }
    count >= top_n { exit }
    NF < 1 { next }
    { if (trim($1) == "") next }
    {
      ip = trim($1)
      sent = trim($2)
      received = trim($3)
      loss = trim($4)
      latency = trim($5)
      speed = trim($6)
      region = trim($7)
      count++
      printf("[router-local] candidate_%d ip=%s sent=%s recv=%s loss=%s latency=%s speed=%s region=%s\n", count, ip, sent, received, loss, latency, speed, region)
    }
  ' "$RESULT_PATH"
}

LAST_GOOD_IP=$(json_get_string "$STATE_LAST_GOOD_KEY" "$STATE_PATH")
LAST_STATE_STATUS=$(json_get_string "status" "$STATE_PATH")

if [ "$CFST_SKIP_RUN" != "1" ]; then
  if ! run_cfst; then
    if [ -n "$LAST_GOOD_IP" ]; then
      write_error_with_fallback "$LAST_GOOD_IP" "cfst run failed"
      log "[router-local] cfst run failed, fallback to last good ip: $LAST_GOOD_IP"
      exit 0
    fi
    log_err "[router-local] cfst run failed and no last good ip available"
    exit 1
  fi
fi

if [ ! -s "$RESULT_PATH" ]; then
  if [ -n "$LAST_GOOD_IP" ]; then
    write_error_with_fallback "$LAST_GOOD_IP" "cfst result file missing or empty"
    log "[router-local] empty result, fallback to last good ip: $LAST_GOOD_IP"
    exit 0
  fi
  log_err "[router-local] result file missing or empty: $RESULT_PATH"
  exit 1
fi

if [ "${CFST_DISABLE_DOWNLOAD:-0}" = "1" ]; then
  BEST_LINE=$(sed -n '2p' "$RESULT_PATH" | tr -d '\r')
else
  # 优先挑选下载测速大于 0 的最优行
  BEST_LINE=$(awk -F',' '
    function trim(v) { gsub(/\r/, "", v); sub(/^[[:space:]]+/, "", v); sub(/[[:space:]]+$/, "", v); return v }
    NR > 1 && NF >= 6 {
      speed = trim($6) + 0;
      if (speed > 0) { print $0; exit }
    }
  ' "$RESULT_PATH" | tr -d '\r')
  # 若所有候选均为 0.00 下载速度（测速失败）且有 last_good，置空以触发 fallback
  if [ -z "$BEST_LINE" ] && [ -n "$LAST_GOOD_IP" ]; then
    BEST_LINE=""
  elif [ -z "$BEST_LINE" ]; then
    BEST_LINE=$(sed -n '2p' "$RESULT_PATH" | tr -d '\r')
  fi
fi
BEST_IP=$(printf '%s' "$BEST_LINE" | cut -d',' -f1 | tr -d ' ')
SOURCE_COUNT=$(awk -F',' 'NR > 1 && NF > 0 { count++ } END { print count + 0 }' "$RESULT_PATH")
TOP_CANDIDATES_JSON=$(build_top_candidates_json)

if [ -z "$BEST_IP" ]; then
  if [ -n "$LAST_GOOD_IP" ]; then
    write_error_with_fallback "$LAST_GOOD_IP" "no valid ip found in cfst result"
    log "[router-local] no valid ip found, fallback to last good ip: $LAST_GOOD_IP"
    exit 0
  fi
  log_err "[router-local] no valid ip found in result file"
  exit 1
fi

write_success_outputs "$BEST_IP" "$TOP_CANDIDATES_JSON" "$SOURCE_COUNT"
log_update_summary "$BEST_IP" "$SOURCE_COUNT"