关于用量信息的持久储存

[Moha-Master]

现在重启之后数据就没了，希望能像日志一样持续存储🤔
不过让AI写了个💩脚本，可以放在crontab里面定时调用接口导出和导入用量信息😋

#!/usr/bin/env bash
# Sync CLI Proxy usage snapshot with server using systemd-aware heuristic.
# Defaults may be overridden via env or by editing variables below.

set -euo pipefail

# Simple config - fill these variables at the top of the script
# KEY: plaintext management key (Authorization: Bearer <KEY>)
# URL: base URL for the app, e.g. http://127.0.0.1:8905
# OUTPUT_DIR: directory where exported snapshot will be stored (e.g. /webservices/cli-proxy-api/logs)
# SYSTEMD_UNIT_NAME: systemd unit name for the service (e.g. cli-proxy-api.service)
KEY=""                 # <-- set your management key here
URL=""  # <-- set your management API base URL here
OUTPUT_DIR=""    # <-- set where to write usage-export-latest.json
SYSTEMD_UNIT_NAME="" # <-- set systemd unit name

CURL_BIN="curl"
JQ_BIN="jq"

# Derived variables (do not edit)
MGMT_BASE="${URL%/}/v0/management"
BACKUP_DIR="${OUTPUT_DIR%/}"
SNAPSHOT_FILE="$BACKUP_DIR/usage-export-latest.json"

log() { printf "[%s] %s\n" "$(date -u +%FT%TZ)" "$*"; }
err() { log "ERROR: $*" >&2; }

ensure_deps() {
  command -v "$CURL_BIN" >/dev/null 2>&1 || { err "curl not found"; exit 2; }
  command -v "$JQ_BIN" >/dev/null 2>&1 || { err "jq not found"; exit 2; }
}

read_key() {
  if [[ -z "$KEY" ]]; then
    err "KEY is empty. Please set the KEY variable at the top of the script"
    return 1
  fi
  return 0
}

epoch_from_maybe_iso() {
  local v="$1"
  if [[ "$v" =~ ^[0-9]+$ ]]; then
    printf "%s" "$v"
    return 0
  fi
  # attempt parse by date - ISO or common formats
  date -d "$v" +%s 2>/dev/null || return 1
}

get_local_exported_at() {
  if [[ ! -f "$SNAPSHOT_FILE" ]]; then
    echo "0"
    return 0
  fi
  local v
  v=$($JQ_BIN -r '.exported_at // empty' "$SNAPSHOT_FILE" 2>/dev/null || true)
  if [[ -z "$v" ]]; then
    # no exported_at field - fallback to file mtime
    stat -c %Y "$SNAPSHOT_FILE" 2>/dev/null || echo 0
    return 0
  fi
  epoch_from_maybe_iso "$v" || echo 0
}

get_systemd_active_epoch() {
  # returns empty string on failure
  if ! command -v systemctl >/dev/null 2>&1; then
    echo ""
    return 0
  fi
  local ts
  ts=$(systemctl show -p ActiveEnterTimestamp --value "$SYSTEMD_UNIT_NAME" 2>/dev/null || true)
  if [[ -z "$ts" ]]; then
    echo ""
    return 0
  fi
  date -d "$ts" +%s 2>/dev/null || echo ""
}

server_export() {
  $CURL_BIN -sS -H "Authorization: Bearer $KEY" "$MGMT_BASE/usage/export"
}

server_usage_total() {
  $CURL_BIN -sS -H "Authorization: Bearer $KEY" "$MGMT_BASE/usage" | \
    $JQ_BIN -r '.usage.total_requests // .total_requests // 0' 2>/dev/null || echo 0
}

local_total_requests() {
  if [[ ! -f "$SNAPSHOT_FILE" ]]; then
    echo 0
    return 0
  fi
  $JQ_BIN -r '.usage.total_requests // .total_requests // 0' "$SNAPSHOT_FILE" 2>/dev/null || echo 0
}

save_snapshot_atomic() {
  local tmp
  tmp=$(mktemp)
  cat > "$tmp"
  mkdir -p "$BACKUP_DIR"
  mv "$tmp" "$SNAPSHOT_FILE"
}

do_export_and_save() {
  log "Exporting usage from server..."
  local resp
  if ! resp=$(server_export); then
    err "Failed to export from server"
    return 1
  fi
  # Validate JSON
  if ! printf '%s' "$resp" | $JQ_BIN . >/dev/null 2>&1; then
    err "Server export returned invalid JSON"
    return 1
  fi
  mkdir -p "$BACKUP_DIR"
  printf '%s' "$resp" > "$SNAPSHOT_FILE.tmp" && mv "$SNAPSHOT_FILE.tmp" "$SNAPSHOT_FILE"
  log "Export saved to $SNAPSHOT_FILE"
  return 0
}

do_import_local_snapshot() {
  if [[ ! -f "$SNAPSHOT_FILE" ]]; then
    err "No local snapshot to import"
    return 1
  fi
  log "Importing local snapshot to server..."
  if $CURL_BIN -sS -X POST -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \
      --data-binary "@$SNAPSHOT_FILE" "$MGMT_BASE/usage/import" >/dev/null; then
    log "Import request sent successfully"
    return 0
  else
    err "Import request failed"
    return 1
  fi
}

main() {
  ensure_deps
  read_key || exit 3

  mkdir -p "$BACKUP_DIR"

  # If no snapshot exists, export and save then exit
  if [[ ! -f "$SNAPSHOT_FILE" ]]; then
    log "No local snapshot found, performing initial export"
    do_export_and_save || exit 4
    exit 0
  fi

  local_exported_at=$(get_local_exported_at)
  log "Local snapshot exported_at: $local_exported_at"

  systemd_epoch=$(get_systemd_active_epoch)
  if [[ -n "$systemd_epoch" ]]; then
    log "systemd ActiveEnterTimestamp epoch: $systemd_epoch"
    if (( systemd_epoch > local_exported_at )); then
      log "Detected service restart since last export (systemd). Will import local snapshot."
      do_import_local_snapshot && do_export_and_save || exit 5
      exit 0
    else
      log "No restart detected (systemd). Will export and update local snapshot."
      do_export_and_save || exit 6
      exit 0
    fi
  fi

  # Fallback heuristic: compare total_requests
  log "systemd info unavailable; falling back to total_requests heuristic"
  server_total=$(server_usage_total) || server_total=0
  local_total=$(local_total_requests) || local_total=0
  log "server total_requests: $server_total; local total_requests: $local_total"
  if (( server_total < local_total )); then
    log "Server total is less than local -> likely restart. Importing local snapshot."
    do_import_local_snapshot && do_export_and_save || exit 7
    exit 0
  else
    log "Server seems ahead or equal -> exporting fresh snapshot"
    do_export_and_save || exit 8
    exit 0
  fi
}

if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
  cat <<EOF
Usage: $0
Environment/vars you can override at runtime:
  MGMT_KEY_FILE  - path to management key (default: $MGMT_KEY_FILE)
  BACKUP_DIR     - directory to keep snapshots (default: $BACKUP_DIR)
  SNAPSHOT_FILE  - path to latest snapshot file (default: $SNAPSHOT_FILE)
  SERVICE_UNIT   - systemd unit name for the service (default: $SERVICE_UNIT)
  MGMT_HOST      - management API base host (default: $MGMT_HOST)

The script will export/import usage snapshots based on systemd ActiveEnterTimestamp
or fall back to comparing total_requests when systemd is unavailable.
EOF
  exit 0
fi

main "$@"