~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/vuln-notif

0
0
main
142 lines · 3.6 KB Raw History
#!/usr/bin/env bash
# Start/stop/status a local RustFS (S3-compatible) for the S3 e2e scripts.
set -euo pipefail

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

if [ -z "${RUSTFS_BIN:-}" ]; then
  RUSTFS_BIN=$(command -v rustfs || true)
fi
PORT=${PORT:-9000}
ACCESS_KEY=${ACCESS_KEY:-rustfsadmin}
SECRET_KEY=${SECRET_KEY:-rustfsadmin}
BUCKET=${BUCKET:-vuln-notif-test}
STATE_ROOT=${STATE_ROOT:-$REPO_DIR/.state}
STATE_DIR=${STATE_DIR:-$STATE_ROOT/rustfs}
DATA_DIR=${DATA_DIR:-$STATE_DIR/data}
LOG_DIR=${LOG_DIR:-$STATE_DIR/logs}
PID_FILE=$STATE_DIR/rustfs.pid
SERVER_LOG=$LOG_DIR/rustfs.out
ENDPOINT=http://127.0.0.1:$PORT

log() { printf '%s\n' "$*" >&2; }
die() { printf 'error: %s\n' "$*" >&2; exit 1; }

pid_alive() {
  [ -f "$PID_FILE" ] || return 1
  local pid
  pid=$(cat "$PID_FILE" 2>/dev/null) || return 1
  [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null
}

healthy() {
  curl -fsS --max-time 2 -o /dev/null "$ENDPOINT/health/ready" 2>/dev/null
}

probe() {
  (
    cd "$REPO_DIR" || exit 1
    cargo run --example s3_probe -- \
      --endpoint "$ENDPOINT" \
      --bucket "$BUCKET" \
      --access-key "$ACCESS_KEY" \
      --secret-key "$SECRET_KEY"
  )
}

start() {
  if pid_alive; then
    log "RustFS already running (pid $(cat "$PID_FILE"))"
    printf '%s\n' "$ENDPOINT"
    return 0
  fi
  [ -n "$RUSTFS_BIN" ] ||
    die "rustfs not found on PATH and not set via RUSTFS_BIN (set RUSTFS_BIN=/path/to/rustfs)"
  if healthy; then
    die "something is already serving $ENDPOINT/health/ready (port $PORT is in use)"
  fi
  mkdir -p "$DATA_DIR" "$LOG_DIR" "$STATE_DIR"
  : >"$SERVER_LOG"
  log "starting RustFS on $ENDPOINT (data $DATA_DIR, log $SERVER_LOG)"
  (
    cd "$STATE_DIR" || exit 1
    exec env RUSTFS_OBS_LOG_DIRECTORY="$LOG_DIR" RUSTFS_OBS_USE_STDOUT=true \
      nohup "$RUSTFS_BIN" server \
      --address "127.0.0.1:$PORT" \
      --access-key "$ACCESS_KEY" \
      --secret-key "$SECRET_KEY" \
      "$DATA_DIR"
  ) >>"$SERVER_LOG" 2>&1 &
  local pid=$!
  printf '%s\n' "$pid" >"$PID_FILE"
  local i
  for i in $(seq 1 60); do
    if healthy; then
      log "RustFS ready (pid $pid, log $SERVER_LOG)"
      if ! probe >&2; then
        stop >/dev/null 2>&1 || true
        die "S3 bucket probe failed"
      fi
      printf '%s\n' "$ENDPOINT"
      return 0
    fi
    if ! kill -0 "$pid" 2>/dev/null; then
      rm -f "$PID_FILE"
      log "RustFS exited during startup; last log lines:"
      tail -n 30 "$SERVER_LOG" >&2 || true
      die "startup failed"
    fi
    sleep 1
  done
  kill -TERM "$pid" 2>/dev/null || true
  rm -f "$PID_FILE"
  die "timed out after 60s waiting for $ENDPOINT/health/ready (see $SERVER_LOG)"
}

stop() {
  if ! pid_alive; then
    rm -f "$PID_FILE"
    log "RustFS is not running"
    return 0
  fi
  local pid i
  pid=$(cat "$PID_FILE")
  kill -TERM "$pid" 2>/dev/null || true
  for i in $(seq 1 80); do
    kill -0 "$pid" 2>/dev/null || break
    sleep 0.25
  done
  if kill -0 "$pid" 2>/dev/null; then
    log "RustFS did not exit after SIGTERM; sending SIGKILL"
    kill -KILL "$pid" 2>/dev/null || true
  fi
  wait "$pid" 2>/dev/null || true
  rm -f "$PID_FILE"
  log "stopped RustFS pid $pid"
}

status() {
  if pid_alive; then
    local health=unhealthy
    if healthy; then health=healthy; fi
    printf 'running pid=%s endpoint=%s health=%s data=%s logs=%s\n' \
      "$(cat "$PID_FILE")" "$ENDPOINT" "$health" "$DATA_DIR" "$LOG_DIR"
    return 0
  fi
  printf 'not running (state dir %s)\n' "$STATE_DIR"
  return 1
}

usage() {
  printf 'usage: %s start|stop|status\n' "$0" >&2
  exit 2
}

[ $# -eq 1 ] || usage
case "$1" in
start) start ;;
stop) stop ;;
status) status ;;
*) usage ;;
esac