#!/bin/sh
# fillrate-task: docker_mem_cap
# Cap the Docker cgroupfs container parent so one renter job cannot OOM the
# host. Machine 152178 (31 GiB RAM, cgroup v2, task_memcg=/docker/<id>) had a
# python process at about 21.5 GiB RSS. The kernel OOM killer was global
# (CONSTRAINT_NONE), so it killed vastai/kaalia and took Docker down with the
# job. vastai.service stays in system.slice; the cap is on the container
# parent, not on the daemon.
#
# The ceiling is the parent cgroup, so every container under it shares one
# 24G budget. It is not a per-container docker --memory flag.
#
# Constants (not ticket fields; cgroup v2 suffixes are 1024-based):
#   memory.max=24G  memory.high=22G  memory.swap.max=0
#
# Ticket mode (FILLRATE_MODE), required:
#   dry-run   read-only report. May run while a container is up.
#   apply     idempotent. Reports already-applied when the cap and the unit
#             are already in place. Refuses with rentals-present if any
#             container is running. Never stops or kills a container.
#   rollback  restore the backed-up values and remove the unit. Same rental
#             refusal.
#
# apply backs up the previous values and any unit under
# /var/lib/fillrate/backup/docker-mem-cap-<stamp>, writes the three files,
# and installs fillrate-docker-mem-cap.service (oneshot, After=docker.service,
# Before=vastai.service) so a later Docker start writes the cap again.
# It does not edit /etc/docker/daemon.json, does not change the cgroup
# driver, does not restart docker or vastai, and never reboots.
#
# Verification: parent files read back as the cap; docker run --pull never
# --rm of a local image at most 512 MiB (no pull) lands under that parent
# and under the cap; docker and vastai are still active. On failure the
# backup is restored and the exit status is 2.
#
# Refuses, it does not no-op, when the hierarchy is not pure cgroup v2, when
# Docker's cgroup driver is systemd (reason systemd-cgroup-driver), or when
# the container parent is anything other than /sys/fs/cgroup/docker
# (reason cgroup-layout).
#
# FILLRATE_* path overrides below are for tests. A real run uses the defaults.
# 24G / 22G / 0 are not overridable.

set -u

CG=${FILLRATE_CGROUP_ROOT:-/sys/fs/cgroup}
DAEMON_JSON=${FILLRATE_DAEMON_JSON:-/etc/docker/daemon.json}
MOUNTS=${FILLRATE_PROC_MOUNTS:-/proc/mounts}
SELF_CGROUP=${FILLRATE_PROC_CGROUP:-/proc/self/cgroup}
PROC_ROOT=${FILLRATE_PROC_ROOT:-/proc}
BACKUP_ROOT=${FILLRATE_BACKUP_ROOT:-/var/lib/fillrate/backup}
STATE=${FILLRATE_STATE:-/var/lib/fillrate-runner/docker-mem-cap}
UNIT=${FILLRATE_UNIT:-/etc/systemd/system/fillrate-docker-mem-cap.service}
UNIT_NAME=fillrate-docker-mem-cap.service

MEM_MAX_SPEC=24G
MEM_HIGH_SPEC=22G
MEM_SWAP_SPEC=0
MEM_MAX_BYTES=$((24 * 1024 * 1024 * 1024))
MEM_HIGH_BYTES=$((22 * 1024 * 1024 * 1024))
SMALL_IMAGE_MAX=$((512 * 1024 * 1024))
PARENT=$CG/docker
PARENT_REL=/docker

EXPIRES=${FILLRATE_EXPIRES:-0}
MODE=${FILLRATE_MODE:-}
STAMP=$(date +%Y%m%d-%H%M%S)-$$
LOG=""
PARENT_CREATED=no

say() {
  printf '%s\n' "$*"
  if [ "$MODE" != "dry-run" ] && [ -n "$LOG" ]; then
    printf '%s %s\n' "$(date +%H:%M:%S 2>/dev/null || echo now)" "$*" >> "$LOG"
  fi
}

refuse() {
  say "refusing: $1"
  say "summary: docker_mem_cap result=refused reason=$1"
  exit 1
}

detail() {
  say "detail=$1"
}

open_log() {
  mkdir -p "$STATE" || refuse "state-dir"
  chmod 700 "$STATE" || true
  LOG="$STATE/run-$STAMP.log"
  : > "$LOG" || refuse "state-log"
  chmod 644 "$LOG" || true
}

read_val() {
  tr -d '[:space:]' < "$1"
}

to_bytes() {
  v=$(printf '%s' "$1" | tr -d '[:space:]')
  case "$v" in
    max) printf '%s\n' max; return 0 ;;
    "") return 1 ;;
  esac
  num=$v
  mul=1
  case "$v" in
    *[Kk]) num=${v%[Kk]}; mul=1024 ;;
    *[Mm]) num=${v%[Mm]}; mul=$((1024 * 1024)) ;;
    *[Gg]) num=${v%[Gg]}; mul=$((1024 * 1024 * 1024)) ;;
    *[Tt]) num=${v%[Tt]}; mul=$((1024 * 1024 * 1024 * 1024)) ;;
  esac
  case "$num" in
    ""|*[!0-9]*) return 1 ;;
  esac
  # shellcheck disable=SC2003
  printf '%s\n' $((num * mul))
}

write_val() {
  file=$1
  spec=$2
  printf '%s\n' "$spec" > "$file" || return 1
  got=$(read_val "$file") || return 1
  want=$(to_bytes "$spec") || return 1
  # The kernel reads back bytes (or max). A plain-file stand-in reads back the
  # text we wrote. Either one means the write landed; a rejected write leaves
  # the previous value, which matches neither.
  [ "$got" = "$want" ] || [ "$got" = "$spec" ]
}

# current high (bytes or max) would reject a lower memory.max
high_blocks_max() {
  cur=$1
  target=$2
  if [ "$cur" = max ] && [ "$target" != max ]; then
    return 0
  fi
  if [ "$cur" = max ] || [ "$target" = max ]; then
    return 1
  fi
  [ "$cur" -gt "$target" ]
}

apply_triple() {
  dir=$1
  max_spec=$2
  high_spec=$3
  swap_spec=$4
  cur_high=$(read_val "$dir/memory.high") || return 1
  cur_b=$(to_bytes "$cur_high") || return 1
  max_b=$(to_bytes "$max_spec") || return 1
  if high_blocks_max "$cur_b" "$max_b"; then
    write_val "$dir/memory.high" "$high_spec" || return 1
  fi
  write_val "$dir/memory.max" "$max_spec" || return 1
  write_val "$dir/memory.high" "$high_spec" || return 1
  write_val "$dir/memory.swap.max" "$swap_spec" || return 1
}

service_state() {
  systemctl is-active "$1" 2>/dev/null | tr -d '[:space:]' || true
}

unit_body() {
  cat << 'EOF'
[Unit]
Description=Fillrate cap on the Docker cgroupfs container parent (24G)
After=docker.service
Before=vastai.service
PartOf=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/sh -c 'drv=$(docker info --format "{{.CgroupDriver}} {{.CgroupVersion}}"); [ "$drv" = "cgroupfs 2" ] || exit 1; d=/sys/fs/cgroup/docker; [ -d "$d" ] || mkdir "$d"; echo 24G > "$d/memory.max"; echo 22G > "$d/memory.high"; echo 0 > "$d/memory.swap.max"'

[Install]
WantedBy=docker.service
EOF
}

unit_matches() {
  [ -f "$UNIT" ] || return 1
  [ -L "$UNIT" ] && return 1
  unit_body | cmp -s - "$UNIT"
}

unit_enabled() {
  st=$(systemctl is-enabled "$UNIT_NAME" 2>/dev/null | tr -d '[:space:]' || true)
  [ "$st" = enabled ]
}

limits_match() {
  [ -f "$PARENT/memory.max" ] || return 1
  [ "$(to_bytes "$(read_val "$PARENT/memory.max")")" = "$MEM_MAX_BYTES" ] || return 1
  [ "$(to_bytes "$(read_val "$PARENT/memory.high")")" = "$MEM_HIGH_BYTES" ] || return 1
  [ "$(to_bytes "$(read_val "$PARENT/memory.swap.max")")" = "0" ]
}

running_ids() {
  docker ps -q || return 1
}

# Pure cgroup v2, cgroupfs driver, parent exactly $PARENT.
detect() {
  [ -f "$MOUNTS" ] || { detail "mounts-missing"; refuse "cgroup-layout"; }
  [ -f "$SELF_CGROUP" ] || { detail "self-cgroup-missing"; refuse "cgroup-layout"; }
  bad_mount=$(awk -v root="$CG" '
    $3 == "cgroup" { bad = 1 }
    $2 == root && $3 == "cgroup2" { ok = 1 }
    END { if (bad || !ok) print "bad" }
  ' "$MOUNTS")
  [ -z "$bad_mount" ] || { detail "cgroup-v1-or-hybrid"; refuse "cgroup-layout"; }
  if grep -E -q '^[1-9]+:' "$SELF_CGROUP"; then
    detail "cgroup-v1-or-hybrid"
    refuse "cgroup-layout"
  fi
  grep -E -q '^0::' "$SELF_CGROUP" || { detail "cgroup-v1-or-hybrid"; refuse "cgroup-layout"; }

  command -v docker >/dev/null 2>&1 || refuse "no-docker"
  command -v systemctl >/dev/null 2>&1 || refuse "no-systemctl"
  command -v awk >/dev/null 2>&1 || refuse "no-awk"

  dst=$(service_state docker)
  [ "$dst" = active ] || refuse "docker-inactive"

  driver=$(docker info --format '{{.CgroupDriver}}' 2>/dev/null | tr -d '[:space:]') || driver=""
  ver=$(docker info --format '{{.CgroupVersion}}' 2>/dev/null | tr -d '[:space:]') || ver=""
  [ -n "$driver" ] && [ -n "$ver" ] || { detail "docker-info"; refuse "cgroup-layout"; }
  if [ "$driver" = systemd ]; then
    detail "docker-info"
    refuse "systemd-cgroup-driver"
  fi
  [ "$driver" = cgroupfs ] && [ "$ver" = 2 ] || { detail "docker-info-driver"; refuse "cgroup-layout"; }

  if [ -L "$DAEMON_JSON" ]; then
    detail "daemon-json-symlink"
    refuse "cgroup-layout"
  fi
  if [ -f "$DAEMON_JSON" ]; then
    parsed=$(awk '
      {
        line = $0
        gsub(/[[:space:]]/, "", line)
        if (line ~ /native\.cgroupdriver=systemd/) print "driver=systemd"
        else if (line ~ /native\.cgroupdriver=cgroupfs/) print "driver=cgroupfs"
        else if (line ~ /native\.cgroupdriver=/) print "driver=other"
        if (match(line, /"cgroup-parent":"[^"]*"/)) {
          s = substr(line, RSTART, RLENGTH)
          n = split(s, a, "\"")
          if (n >= 4) print "parent=" a[4]
        }
      }
    ' "$DAEMON_JSON")
    printf '%s\n' "$parsed" | grep -q '^driver=systemd$' && {
      detail "daemon-json-requests-systemd"
      refuse "systemd-cgroup-driver"
    }
    printf '%s\n' "$parsed" | grep -q '^driver=other$' && {
      detail "daemon-json-driver"
      refuse "cgroup-layout"
    }
    parent_cfg=$(printf '%s\n' "$parsed" | awk -F= '$1=="parent"{print $2; exit}')
    case "$parent_cfg" in
      ""|/docker|docker) ;;
      *) detail "custom-cgroup-parent"; refuse "cgroup-layout" ;;
    esac
  fi

  cgshow=$(systemctl show docker.service -p ControlGroup --value 2>/dev/null | tr -d '[:space:]' || true)
  case "$cgshow" in
    /system.slice/docker.service|system.slice/docker.service) ;;
    *) detail "docker-service-cgroup"; refuse "cgroup-layout" ;;
  esac

  for scope in "$CG"/system.slice/docker-*.scope; do
    if [ -d "$scope" ]; then
      detail "systemd-scope-present"
      refuse "cgroup-layout"
    fi
  done

  if [ -L "$PARENT" ]; then
    detail "parent-symlink"
    refuse "cgroup-layout"
  fi
  if [ -e "$PARENT" ] && [ ! -d "$PARENT" ]; then
    detail "parent-not-dir"
    refuse "cgroup-layout"
  fi
  if [ -d "$PARENT" ]; then
    if [ ! -f "$PARENT/memory.max" ] || [ ! -f "$PARENT/memory.high" ] || [ ! -f "$PARENT/memory.swap.max" ]; then
      detail "memory-controller-missing"
      refuse "cgroup-layout"
    fi
  fi

  ids=$(running_ids) || refuse "docker-ps-failed"
  RUNNING=0
  if [ -n "$ids" ]; then
    for cid in $ids; do
      RUNNING=$((RUNNING + 1))
      pid=$(docker inspect --format '{{.State.Pid}}' "$cid" 2>/dev/null | tr -d '[:space:]') || pid=""
      case "$pid" in
        ""|*[!0-9]*|0) detail "container-cgroup"; refuse "cgroup-layout" ;;
      esac
      line=$(awk -F: '$1==0 { print $3; exit }' "$PROC_ROOT/$pid/cgroup" 2>/dev/null) || line=""
      case "$line" in
        "$PARENT_REL"/*) ;;
        *) detail "container-cgroup"; refuse "cgroup-layout" ;;
      esac
    done
  fi

  DRIVER=$driver
  CGVER=$ver
  DOCKER_CG=$cgshow
}

require_idle() {
  ids=$(running_ids) || refuse "docker-ps-failed"
  if [ -n "$ids" ]; then
    refuse "rentals-present"
  fi
}

value_or_absent() {
  if [ -f "$1" ]; then
    read_val "$1"
  else
    printf '%s\n' absent
  fi
}

report_dry() {
  vmax=$(value_or_absent "$PARENT/memory.max")
  vhigh=$(value_or_absent "$PARENT/memory.high")
  vswap=$(value_or_absent "$PARENT/memory.swap.max")
  if [ -f "$UNIT" ]; then
    if unit_enabled; then ust=enabled; else ust=disabled; fi
  else
    ust=absent
  fi
  if [ -d "$PARENT" ] && limits_match && unit_matches && unit_enabled; then
    would=already-applied
  else
    would=apply
  fi
  if [ -d "$PARENT" ]; then pst=present; else pst=absent; fi
  vast=$(service_state vastai)
  [ -n "$vast" ] || vast=unknown
  say "driver=$DRIVER version=$CGVER parent=$PARENT parent_state=$pst docker_service_cgroup=$DOCKER_CG"
  say "memory.max=$vmax memory.high=$vhigh memory.swap.max=$vswap"
  say "unit=$ust running=$RUNNING vastai=$vast cap=${MEM_MAX_SPEC}/${MEM_HIGH_SPEC}/swap${MEM_SWAP_SPEC}"
  say "summary: docker_mem_cap result=dry-run driver=$DRIVER version=$CGVER parent=$PARENT parent_state=$pst max=$vmax high=$vhigh swap=$vswap running=$RUNNING unit=$ust would=$would"
}

ensure_parent() {
  if [ -d "$PARENT" ]; then
    return 0
  fi
  mkdir -p "$PARENT" || { detail "parent-mkdir"; refuse "cgroup-layout"; }
  if [ ! -f "$PARENT/memory.max" ] || [ ! -f "$PARENT/memory.high" ] || [ ! -f "$PARENT/memory.swap.max" ]; then
    rmdir "$PARENT" 2>/dev/null || true
    detail "memory-controller-missing"
    refuse "cgroup-layout"
  fi
  PARENT_CREATED=yes
}

backup_current() {
  BK="$BACKUP_ROOT/docker-mem-cap-$STAMP"
  mkdir -p "$BK" || refuse "backup-failed"
  chmod 700 "$BK" || true
  printf '%s\n' "$(read_val "$PARENT/memory.max")" > "$BK/memory.max"
  printf '%s\n' "$(read_val "$PARENT/memory.high")" > "$BK/memory.high"
  printf '%s\n' "$(read_val "$PARENT/memory.swap.max")" > "$BK/memory.swap.max"
  printf '%s\n' "$PARENT" > "$BK/parent.path"
  printf '%s\n' "$PARENT_CREATED" > "$BK/parent.created"
  if [ -f "$UNIT" ] && [ ! -L "$UNIT" ]; then
    printf '%s\n' yes > "$BK/unit.existed"
    cp -- "$UNIT" "$BK/unit.body" || refuse "backup-failed"
    if unit_enabled; then printf '%s\n' enabled; else printf '%s\n' disabled; fi > "$BK/unit.enabled"
  else
    printf '%s\n' no > "$BK/unit.existed"
    printf '%s\n' absent > "$BK/unit.enabled"
  fi
  printf '%s\n' "$BK" > "$STATE/latest-backup"
  say "backup=$BK"
}

latest_backup() {
  [ -f "$STATE/latest-backup" ] || return 1
  p=$(read_val "$STATE/latest-backup")
  [ -n "$p" ] && [ -d "$p" ] || return 1
  printf '%s\n' "$p"
}

install_unit() {
  mkdir -p "$(dirname "$UNIT")" || return 1
  tmp=$(mktemp "$STATE/unit.XXXXXX") || return 1
  unit_body > "$tmp" || { rm -f "$tmp"; return 1; }
  if [ -f "$UNIT" ] && [ ! -L "$UNIT" ] && cmp -s "$tmp" "$UNIT"; then
    rm -f "$tmp"
  else
    cat "$tmp" > "$UNIT" || { rm -f "$tmp"; return 1; }
    rm -f "$tmp"
    chmod 644 "$UNIT" || return 1
  fi
  [ -L "$UNIT" ] && return 1
  systemctl daemon-reload >> "$LOG" 2>&1 || return 1
  say "run: systemctl daemon-reload"
  systemctl enable "$UNIT_NAME" >> "$LOG" 2>&1 || return 1
  say "run: systemctl enable $UNIT_NAME"
  systemctl start "$UNIT_NAME" >> "$LOG" 2>&1 || return 1
  say "run: systemctl start $UNIT_NAME"
  unit_matches && unit_enabled
}

write_probe() {
  cat > "$STATE/probe.sh" << EOF
#!/bin/sh
cg=\$(awk -F: '\$1==0 { print \$3; exit }' /proc/self/cgroup)
echo "cgroup=\$cg"
echo "parent_max=\$(cat ${PARENT}/memory.max)"
echo "current=\$(cat ${CG}\$cg/memory.current)"
EOF
  chmod 755 "$STATE/probe.sh" || return 1
}

size_to_bytes() {
  printf '%s\n' "$1" | awk '
    function mul(s) {
      if (s ~ /^[kK][iI]?[bB]?$/) return 1024
      if (s ~ /^[mM][iI]?[bB]?$/) return 1024 * 1024
      if (s ~ /^[gG][iI]?[bB]?$/) return 1024 * 1024 * 1024
      if (s ~ /^[tT][iI]?[bB]?$/) return 1024 * 1024 * 1024 * 1024
      if (s ~ /^[bB]?$/) return 1
      return 0
    }
    {
      if (!match($0, /^[0-9]+(\.[0-9]+)?/)) exit 1
      n = substr($0, 1, RLENGTH)
      u = substr($0, RLENGTH + 1)
      m = mul(u)
      if (m == 0) exit 1
      printf "%.0f\n", n * m
    }
  '
}

parse_probe() {
  text=$1
  path=$(printf '%s\n' "$text" | awk -F= '$1=="cgroup" { print $2; exit }')
  if [ -z "$path" ]; then
    path=$(printf '%s\n' "$text" | awk -F: '$1=="0" { print $3; exit }')
  fi
  case "$path" in
    "$PARENT_REL"/[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]*) ;;
    *) return 1 ;;
  esac
  rest=${path#"$PARENT_REL"/}
  case "$rest" in
    *[!0-9a-f]*|"") return 1 ;;
  esac
  [ "${#rest}" -ge 12 ] && [ "${#rest}" -le 64 ] || return 1
  pmax=$(printf '%s\n' "$text" | awk -F= '$1=="parent_max" { print $2; exit }')
  if [ -n "$pmax" ] && [ "$pmax" != "$MEM_MAX_BYTES" ]; then
    return 1
  fi
  cur=$(printf '%s\n' "$text" | awk -F= '$1=="current" { print $2; exit }')
  if [ -n "$cur" ]; then
    case "$cur" in
      ""|*[!0-9]*) return 1 ;;
    esac
    [ "$cur" -lt "$MEM_MAX_BYTES" ] || return 1
  fi
  return 0
}

probe_image() {
  id=$1
  say "probe image=$id"
  out=$(docker run --pull never --rm --network none --cgroupns=host \
    -v "$STATE/probe.sh:/fillrate-probe.sh:ro" \
    --entrypoint /bin/sh "$id" /fillrate-probe.sh 2>>"$LOG") && parse_probe "$out" && return 0
  out=$(docker run --pull never --rm --network none --cgroupns=host \
    --entrypoint cat "$id" /proc/self/cgroup 2>>"$LOG") && parse_probe "$out" && return 0
  return 1
}

probe_local() {
  list=$(docker images --no-trunc --format '{{.ID}} {{.Size}} {{.Repository}}' 2>>"$LOG") || return 1
  : > "$STATE/images.list"
  printf '%s\n' "$list" | while IFS= read -r line; do
    [ -n "$line" ] || continue
    id=${line%% *}
    rest=${line#* }
    size=${rest%% *}
    case "$id" in
      ""|-*) continue ;;
    esac
    bytes=$(size_to_bytes "$size" 2>/dev/null) || continue
    case "$bytes" in
      ""|*[!0-9]*) continue ;;
    esac
    printf '%s %s\n' "$bytes" "$id"
  done > "$STATE/images.sorted"
  sort -n "$STATE/images.sorted" > "$STATE/images.list"
  tried=0
  while read -r bytes id; do
    [ -n "${id:-}" ] || continue
    [ "$bytes" -le "$SMALL_IMAGE_MAX" ] || continue
    tried=$((tried + 1))
    [ "$tried" -le 8 ] || break
    if probe_image "$id"; then
      printf '%s\n' "$id" > "$STATE/probed-image"
      return 0
    fi
  done < "$STATE/images.list"
  return 1
}

services_active() {
  [ "$(service_state docker)" = active ] || return 1
  [ "$(service_state vastai)" = active ] || return 1
}

verify_cap() {
  limits_match || return 1
  unit_matches || return 1
  unit_enabled || return 1
  services_active || return 1
  rm -f "$STATE/probed-image"
  write_probe || return 1
  probe_local || return 1
  services_active || return 1
}

remove_unit() {
  systemctl disable "$UNIT_NAME" >> "$LOG" 2>&1 || true
  say "run: systemctl disable $UNIT_NAME"
  rm -f "$UNIT"
  systemctl daemon-reload >> "$LOG" 2>&1 || return 1
  say "run: systemctl daemon-reload"
}

restore_from_backup() {
  bk=$(latest_backup) || return 1
  bparent=$(read_val "$bk/parent.path") || return 1
  [ "$bparent" = "$PARENT" ] || return 1
  bmax=$(read_val "$bk/memory.max") || return 1
  bhigh=$(read_val "$bk/memory.high") || return 1
  bswap=$(read_val "$bk/memory.swap.max") || return 1
  if [ ! -d "$PARENT" ]; then
    return 1
  fi
  apply_triple "$PARENT" "$bmax" "$bhigh" "$bswap" || return 1
  existed=$(read_val "$bk/unit.existed") || existed=no
  if [ "$existed" = yes ] && [ -f "$bk/unit.body" ]; then
    mkdir -p "$(dirname "$UNIT")" || return 1
    cat "$bk/unit.body" > "$UNIT" || return 1
    chmod 644 "$UNIT" || return 1
    systemctl daemon-reload >> "$LOG" 2>&1 || return 1
    en=$(read_val "$bk/unit.enabled" 2>/dev/null || true)
    if [ "$en" = enabled ]; then
      systemctl enable "$UNIT_NAME" >> "$LOG" 2>&1 || return 1
    else
      systemctl disable "$UNIT_NAME" >> "$LOG" 2>&1 || true
    fi
  else
    remove_unit || return 1
  fi
  created=$(read_val "$bk/parent.created" 2>/dev/null || echo no)
  if [ "$created" = yes ]; then
    kids=$(find "$PARENT" -mindepth 1 -maxdepth 1 -type d 2>/dev/null || true)
    procs=""
    [ -f "$PARENT/cgroup.procs" ] && procs=$(tr -d '[:space:]' < "$PARENT/cgroup.procs" || true)
    if [ -z "$kids" ] && [ -z "$procs" ]; then
      rmdir "$PARENT" 2>/dev/null || say "parent directory remains after restore"
    fi
  fi
  say "restored backup=$bk"
  return 0
}

fail_verify() {
  reason=$1
  say "verify failed: $reason"
  ids=$(running_ids) || ids=""
  if [ -n "$ids" ]; then
    say "summary: docker_mem_cap result=verify-failed reason=$reason restored=no"
    exit 2
  fi
  if restore_from_backup; then
    say "summary: docker_mem_cap result=verify-failed reason=$reason restored=yes"
  else
    say "summary: docker_mem_cap result=verify-failed reason=$reason restored=no"
  fi
  exit 2
}

do_rollback() {
  require_idle
  vast=$(service_state vastai)
  [ "$vast" = active ] || refuse "vastai-inactive"
  if ! restore_from_backup; then
    refuse "no-backup"
  fi
  if [ -d "$PARENT" ]; then
    vmax=$(read_val "$PARENT/memory.max")
    vhigh=$(read_val "$PARENT/memory.high")
    vswap=$(read_val "$PARENT/memory.swap.max")
  else
    vmax=absent
    vhigh=absent
    vswap=absent
  fi
  if [ -f "$UNIT" ]; then ust=present; else ust=absent; fi
  say "summary: docker_mem_cap result=rolled-back parent=$PARENT max=$vmax high=$vhigh swap=$vswap unit=$ust"
}

do_apply() {
  require_idle
  vast=$(service_state vastai)
  [ "$vast" = active ] || refuse "vastai-inactive"
  if [ ! -d "$PARENT" ]; then
    ensure_parent
  fi
  if limits_match && unit_matches && unit_enabled; then
    say "already at ${MEM_MAX_SPEC}/${MEM_HIGH_SPEC}/swap${MEM_SWAP_SPEC} with $UNIT_NAME enabled"
    if ! verify_cap; then
      if ! limits_match; then
        fail_verify "parent-limit"
      fi
      if ! services_active; then
        dst=$(service_state docker)
        vst=$(service_state vastai)
        if [ "$dst" != active ]; then
          fail_verify "docker-inactive"
        fi
        if [ "$vst" != active ]; then
          fail_verify "vastai-inactive"
        fi
        fail_verify "services"
      fi
      fail_verify "probe"
    fi
    say "summary: docker_mem_cap result=already-applied parent=$PARENT max=$MEM_MAX_BYTES high=$MEM_HIGH_BYTES swap=0 unit=enabled"
    return 0
  fi
  ensure_parent
  # Keep the original pre-cap backup when the limits are already the target.
  if limits_match && latest_backup >/dev/null 2>&1; then
    say "limits already match; keeping existing backup"
  else
    backup_current
  fi
  if ! apply_triple "$PARENT" "$MEM_MAX_SPEC" "$MEM_HIGH_SPEC" "$MEM_SWAP_SPEC"; then
    say "writing the cap failed"
    if ! restore_from_backup; then
      say "summary: docker_mem_cap result=verify-failed reason=parent-limit restored=no"
      exit 2
    fi
    say "summary: docker_mem_cap result=verify-failed reason=parent-limit restored=yes"
    exit 2
  fi
  if ! install_unit; then
    fail_verify "unit"
  fi
  ids=$(running_ids) || refuse "docker-ps-failed"
  if [ -n "$ids" ]; then
    restore_from_backup || true
    refuse "rentals-present"
  fi
  if ! verify_cap; then
    if ! limits_match; then
      fail_verify "parent-limit"
    fi
    if ! services_active; then
      dst=$(service_state docker)
      vst=$(service_state vastai)
      if [ "$dst" != active ]; then
        fail_verify "docker-inactive"
      fi
      fail_verify "vastai-inactive"
    fi
    fail_verify "probe"
  fi
  say "summary: docker_mem_cap result=applied parent=$PARENT max=$MEM_MAX_BYTES high=$MEM_HIGH_BYTES swap=0 unit=enabled backup=$(read_val "$STATE/latest-backup")"
}

case "$MODE" in
  apply|dry-run|rollback) ;;
  "") refuse "bad-mode" ;;
  *) refuse "bad-mode" ;;
esac

case "$EXPIRES" in
  ""|*[!0-9]*) refuse "ticket-expired" ;;
esac
now=$(date +%s) || refuse "ticket-expired"
[ "$now" -le "$EXPIRES" ] || refuse "ticket-expired"

detect

if [ "$MODE" = dry-run ]; then
  report_dry
  exit 0
fi

open_log
say "mode=$MODE expires=$EXPIRES driver=$DRIVER version=$CGVER parent=$PARENT running=$RUNNING"

case "$MODE" in
  rollback) do_rollback ;;
  apply) do_apply ;;
esac
exit 0
