13.6. Таблица диагностики

mkdir -p /tmp/diaglab && cd /tmp/diaglab

# ─── Исправный сервис ─────────────────────────────────────────────────
cat > good.py <<'PY'
"""Исправный сервис: отвечает на / и на /health."""
import http.server, json, os, threading, time

class H(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        body = json.dumps({"ок": True, "pid": os.getpid()}, ensure_ascii=False).encode()
        self.send_response(200)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)
    def log_message(self, *a): pass

print(f"сервис готов, pid={os.getpid()}", flush=True)
threading.Thread(
    target=http.server.ThreadingHTTPServer(("0.0.0.0", 8000), H).serve_forever,
    daemon=True).start()
while True:
    time.sleep(1)
PY

# ─── Сервис, слушающий только localhost ───────────────────────────────
cat > loopback.py <<'PY'
"""Ошибка 3.1: привязка к 127.0.0.1 вместо 0.0.0.0."""
import http.server, os, threading, time

class H(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200); self.end_headers(); self.wfile.write(b"ok")
    def log_message(self, *a): pass

print(f"слушаю 127.0.0.1:8000, pid={os.getpid()}", flush=True)
threading.Thread(
    target=http.server.ThreadingHTTPServer(("127.0.0.1", 8000), H).serve_forever,
    daemon=True).start()
while True:
    time.sleep(1)
PY

# ─── Сервис, падающий при старте ──────────────────────────────────────
cat > crashing.py <<'PY'
"""Ошибка 1.8: падение при инициализации."""
import sys, time
print("инициализация...", flush=True)
time.sleep(1)
print("ОШИБКА: не удалось подключиться к базе данных", file=sys.stderr, flush=True)
sys.exit(1)
PY

# ─── Потребитель памяти ───────────────────────────────────────────────
cat > hungry.py <<'PY'
"""Ошибка 1.2: исчерпание лимита памяти."""
import time
blocks = []
n = 0
while True:
    blocks.append(bytearray(4 * 1024 * 1024))
    blocks[-1][::4096] = b"\x01" * (len(blocks[-1]) // 4096)
    n += 4
    print(f"выделено {n} МиБ", flush=True)
    time.sleep(0.15)
PY

# ─── Инструмент диагностики по методике ───────────────────────────────
cat > triage.sh <<'SH'
#!/usr/bin/env bash
# Проходит методику из пяти вопросов, останавливаясь на первом
# отрицательном ответе. Выдаёт раздел таблицы и следующую команду.
set -uo pipefail

TARGET="${1:?укажите container}"
PORT="${2:-8000}"

verdict() {
    printf '\n    ДИАГНОЗ:  %s\n' "$1"
    printf '    РАЗДЕЛ:   %s\n' "$2"
    printf '    ДАЛЬШЕ:   %s\n\n' "$3"
}

printf '\n  Диагностика: %s\n\n' "$TARGET"

# ── Шаг 1: создан ли container ────────────────────────────────────────
if ! docker inspect "$TARGET" > /dev/null 2>&1; then
    printf '    [1] container создан?      НЕТ\n'
    verdict "container не создан — ошибка на стороне daemon" \
            "1. Запуск и остановка, запись 1.1" \
            "sudo journalctl -u docker.service --since '5 min ago' -p err"
    exit 1
fi
printf '    [1] container создан?      да\n'

# ── Шаг 2: работает или завершился ────────────────────────────────────
read -r status code oom restarts <<EOF
$(docker inspect "$TARGET" --format '{{.State.Status}} {{.State.ExitCode}} {{.State.OOMKilled}} {{.RestartCount}}')
EOF
printf '    [2] статус?                %s (код %s, перезапусков %s)\n' "$status" "$code" "$restarts"

if [ "$status" != "running" ]; then
    if [ "$oom" = "true" ]; then
        verdict "убит по нехватке памяти в cgroup" \
                "1.2 и раздел 5. Ресурсы" \
                "docker exec/логи: найти причину роста; поднять --memory"
        exit 2
    fi
    case "$code" in
        137)
            stops="$(docker events --since 30m --until 0s --filter "container=$TARGET" \
                --format '{{.Action}}' 2>/dev/null | grep -c '^stop$' || echo 0)"
            if [ "${stops:-0}" -gt 0 ]; then
                verdict "не завершился по SIGTERM за отведённое время" \
                        "1.10 и 1.11" \
                        "проверить обработчик SIGTERM и форму exec в CMD"
            else
                verdict "SIGKILL извне; возможен OOM на уровне host" \
                        "1.3" \
                        "sudo dmesg -T | grep -i 'killed process'"
            fi
            exit 2 ;;
        143) verdict "штатное завершение по SIGTERM" "1.4" "норма"; exit 0 ;;
        126) verdict "файл найден, но не исполняемый" "1.5" \
                     "docker run --rm ОБРАЗ ls -l /путь"; exit 2 ;;
        127) verdict "команда не найдена" "1.6" \
                     "docker run --rm ОБРАЗ which КОМАНДА"; exit 2 ;;
        0)   verdict "процесс отработал и вышел" "1.12" \
                     "главный процесс должен работать в переднем плане"; exit 0 ;;
        *)   verdict "завершился с кодом $code — ошибка приложения" \
                     "1. Запуск и остановка" \
                     "docker logs --tail 50 $TARGET"; exit 2 ;;
    esac
fi

# ── Шаг 3: что вывело приложение ──────────────────────────────────────
loglines="$(docker logs "$TARGET" 2>&1 | grep -c . || echo 0)"
printf '    [3] строк в логах?         %s\n' "$loglines"
if [ "${loglines:-0}" -eq 0 ]; then
    unbuf="$(docker inspect "$TARGET" --format '{{range .Config.Env}}{{println .}}{{end}}' \
        | grep -c PYTHONUNBUFFERED || echo 0)"
    drv="$(docker inspect "$TARGET" --format '{{.HostConfig.LogConfig.Type}}')"
    if [ "${unbuf:-0}" -eq 0 ]; then
        verdict "логи пусты: вероятна буферизация stdout" "2.1" \
                "перезапустить с PYTHONUNBUFFERED=1"
    else
        verdict "логи пусты при заданном PYTHONUNBUFFERED; драйвер: $drv" "2.4" \
                "docker inspect --format '{{.HostConfig.LogConfig.Type}}'"
    fi
    exit 1
fi
if docker logs "$TARGET" 2>&1 | grep -qE 'Traceback|Error|ОШИБКА|Exception'; then
    printf '        в логах есть признаки ошибки:\n'
    docker logs "$TARGET" 2>&1 | grep -E 'Traceback|Error|ОШИБКА|Exception' \
        | tail -2 | sed 's/^/          /'
fi

# ── Шаг 4: проверка здоровья ──────────────────────────────────────────
health="$(docker inspect "$TARGET" --format \
    '{{if .State.Health}}{{.State.Health.Status}}{{else}}нет{{end}}')"
printf '    [4] проверка здоровья?     %s\n' "$health"
if [ "$health" = "unhealthy" ]; then
    printf '        последний вывод проверки:\n'
    docker inspect "$TARGET" --format '{{json .State.Health.Log}}' \
        | python3 -c "
import json, sys
log = json.load(sys.stdin) or []
if log:
    e = log[-1]
    print('          код=' + str(e['ExitCode']) + ' ' + e['Output'].strip()[:60])
" 2>/dev/null
    verdict "проверка здоровья не проходит" "1.8 и 3. Сеть" \
            "причина — в выводе выше; проверить зависимости сервиса"
    exit 2
fi

# ── Шаг 5: отвечает ли изнутри ────────────────────────────────────────
inside="$(docker exec "$TARGET" python -c "
import socket, sys
s = socket.socket(); s.settimeout(3)
try:
    s.connect(('127.0.0.1', $PORT)); print('да')
except OSError as e:
    print('нет:' + (e.strerror or str(e)))
finally:
    s.close()
" 2>/dev/null)"
if [ -z "$inside" ]; then
    printf '    [5] отвечает изнутри?      ПРОВЕРКА НЕ ВЫПОЛНЕНА (нет python в образе)\n'
    verdict "шаг 5 не выполнен — инструмент недоступен в образе" \
            "13.5. Глубокая диагностика" \
            "sidecar: docker run --rm --network container:$TARGET ОБРАЗ ..."
    exit 1
fi
printf '    [5] отвечает изнутри?      %s\n' "$inside"

case "$inside" in
    да)
        # Отвечает внутри — проверяем снаружи
        published="$(docker port "$TARGET" "$PORT" 2>/dev/null | head -1)"
        if [ -z "$published" ]; then
            verdict "работает внутри, порт не опубликован" "3. Сеть" \
                    "docker run -p ХОСТ:$PORT ... или ports в compose.yaml"
            exit 1
        fi
        hostport="${published##*:}"
        outside="$(python3 -c "
import socket
s = socket.socket(); s.settimeout(3)
try:
    s.connect(('127.0.0.1', $hostport)); print('да')
except OSError as e:
    print('нет:' + (e.strerror or str(e)))
finally:
    s.close()
" 2>/dev/null)"
        printf '    [6] отвечает с host?       %s\n' "$outside"
        if [ "$outside" = "да" ]; then
            verdict "сервис работает и доступен снаружи" "—" "проблем не обнаружено"
            exit 0
        fi
        verdict "работает внутри, недоступен снаружи" "3.1 и 3.6" \
                "проверить привязку: слушает ли 0.0.0.0, а не 127.0.0.1"
        exit 1 ;;
    *)
        listen="$(docker exec "$TARGET" python -c "
import socket
s = socket.socket(); s.settimeout(2)
try:
    s.bind(('0.0.0.0', $PORT)); print('порт свободен — приложение НЕ слушает')
except OSError:
    print('порт занят — приложение слушает, но не на 0.0.0.0')
finally:
    s.close()
" 2>/dev/null)"
        printf '        уточнение: %s\n' "$listen"
        case "$listen" in
            *"не на 0.0.0.0"*)
                verdict "приложение привязано к 127.0.0.1" "3.1" \
                        "слушать 0.0.0.0 вместо 127.0.0.1" ;;
            *)
                verdict "приложение не слушает порт $PORT" "1.9 и 3. Сеть" \
                        "docker top $TARGET; проверить, что процесс дошёл до listen" ;;
        esac
        exit 1 ;;
esac
SH
chmod +x triage.sh

fail=0
ok()  { printf '  ✓ %s\n' "$1"; }
bad() { printf '  ✗ %s\n' "$1"; fail=1; }

printf '\n═══ Подготовка: четыре неисправности и один исправный ═══\n'
docker run -d --name t-good -e PYTHONUNBUFFERED=1 -p 18100:8000 \
    -v "$PWD/good.py:/a.py:ro" python:3.13-slim python /a.py > /dev/null
docker run -d --name t-loopback -e PYTHONUNBUFFERED=1 -p 18101:8000 \
    -v "$PWD/loopback.py:/a.py:ro" python:3.13-slim python /a.py > /dev/null
docker run -d --name t-crash -e PYTHONUNBUFFERED=1 \
    -v "$PWD/crashing.py:/a.py:ro" python:3.13-slim python /a.py > /dev/null
docker run -d --name t-oom --memory 64m --memory-swap 64m -e PYTHONUNBUFFERED=1 \
    -v "$PWD/hungry.py:/a.py:ro" python:3.13-slim python /a.py > /dev/null
docker run -d --name t-killed python:3.13-slim sleep 300 > /dev/null
sleep 3 && docker kill t-killed > /dev/null
sleep 12
printf '    пять container'"'"'ов созданы\n'

printf '\n═══ Требования 1-3: методика на четырёх неисправностях ═══\n'

printf '\n  ── упавший при старте ──'
./triage.sh t-crash; rc_crash=$?
printf '  ── исчерпал память ──'
./triage.sh t-oom; rc_oom=$?
printf '  ── привязан к 127.0.0.1 ──'
./triage.sh t-loopback; rc_loop=$?
printf '  ── убит командой kill ──'
./triage.sh t-killed; rc_kill=$?

d_crash="$(./triage.sh t-crash | grep 'ДИАГНОЗ' | sed 's/.*ДИАГНОЗ: *//')"
d_oom="$(./triage.sh t-oom | grep 'ДИАГНОЗ' | sed 's/.*ДИАГНОЗ: *//')"
d_loop="$(./triage.sh t-loopback | grep 'ДИАГНОЗ' | sed 's/.*ДИАГНОЗ: *//')"
d_kill="$(./triage.sh t-killed | grep 'ДИАГНОЗ' | sed 's/.*ДИАГНОЗ: *//')"

uniq_count="$(printf '%s\n%s\n%s\n%s\n' "$d_crash" "$d_oom" "$d_loop" "$d_kill" \
    | sort -u | grep -c .)"
printf '\n    различных диагнозов на четыре неисправности: %s\n' "$uniq_count"
[ "$uniq_count" -eq 4 ] \
    && ok "каждая неисправность получила свой диагноз и раздел таблицы" \
    || bad "диагнозов: $uniq_count из 4"

printf '\n═══ Требование 4: один код 137 — разные диагнозы ═══\n'
printf '    %-14s %-6s %-11s %s\n' "container" "код" "OOMKilled" "диагноз"
printf '    %s\n' "──────────────────────────────────────────────────────────────────────────"
for c in t-oom t-killed; do
    info="$(docker inspect "$c" --format '{{.State.ExitCode}}|{{.State.OOMKilled}}')"
    d="$(./triage.sh "$c" | grep 'ДИАГНОЗ' | sed 's/.*ДИАГНОЗ: *//')"
    printf '    %-14s %-6s %-11s %s\n' "$c" "${info%%|*}" "${info##*|}" "${d:0:44}"
done
[ "$d_oom" != "$d_kill" ] \
    && ok "одинаковый код 137 разведён на два диагноза" \
    || bad "диагнозы совпали"

printf '\n═══ Требование 5: исправный сервис ═══\n'
./triage.sh t-good; rc_good=$?
d_good="$(./triage.sh t-good | grep 'ДИАГНОЗ' | sed 's/.*ДИАГНОЗ: *//')"
printf '    код возврата: %s\n' "$rc_good"
case "$d_good" in
    *"работает и доступен"*) ok "на исправном сервисе ложного диагноза нет (код $rc_good)" ;;
    *) bad "ложный диагноз: $d_good" ;;
esac

printf '\n═══ Требование 6: непроверенное отличается от пройденного ═══\n'
docker run -d --name t-noshell --entrypoint sleep alpine:3.21 300 > /dev/null
sleep 2
noshell_out="$(./triage.sh t-noshell 2>&1)"
echo "$noshell_out" | grep -E '\[5\]|ДИАГНОЗ' | sed 's/^/    /'
case "$noshell_out" in
    *"ПРОВЕРКА НЕ ВЫПОЛНЕНА"*)
        ok "шаг, который не удалось выполнить, помечен явно, а не засчитан" ;;
    *) bad "невыполненный шаг не отмечен" ;;
esac
docker rm -f t-noshell > /dev/null 2>&1

printf '\n═══ Проверка остановки на первом отрицательном ответе ═══\n'
steps_crash="$(./triage.sh t-crash | grep -c '^    \[[0-9]\]')"
steps_good="$(./triage.sh t-good | grep -c '^    \[[0-9]\]')"
printf '    шагов пройдено на упавшем: %s\n' "$steps_crash"
printf '    шагов пройдено на исправном: %s\n' "$steps_good"
[ "$steps_crash" -lt "$steps_good" ] \
    && ok "инструмент останавливается на первом отрицательном ответе" \
    || bad "шагов: $steps_crash и $steps_good"

printf '\n═══ ИТОГ ═══\n'
[ "$fail" -eq 0 ] && echo "  все требования выполнены" || echo "  ЕСТЬ ПРОВАЛЫ"

docker rm -f t-good t-loopback t-crash t-oom t-killed > /dev/null 2>&1
cd /tmp && rm -rf /tmp/diaglab
exit "$fail"

═══ Подготовка: четыре неисправности и один исправный ═══
    пять container'ов созданы

═══ Требования 1-3: методика на четырёх неисправностях ═══

  ── упавший при старте ──
  Диагностика: t-crash

    [1] container создан?      да
    [2] статус?                exited (код 1, перезапусков 0)

    ДИАГНОЗ:  завершился с кодом 1 — ошибка приложения
    РАЗДЕЛ:   1. Запуск и остановка
    ДАЛЬШЕ:   docker logs --tail 50 t-crash

  ── исчерпал память ──
  Диагностика: t-oom

    [1] container создан?      да
    [2] статус?                exited (код 137, перезапусков 0)

    ДИАГНОЗ:  убит по нехватке памяти в cgroup
    РАЗДЕЛ:   1.2 и раздел 5. Ресурсы
    ДАЛЬШЕ:   docker exec/логи: найти причину роста; поднять --memory

  ── привязан к 127.0.0.1 ──
  Диагностика: t-loopback

    [1] container создан?      да
    [2] статус?                running (код 0, перезапусков 0)
    [3] строк в логах?         1
    [4] проверка здоровья?     нет
    [5] отвечает изнутри?      да
    [6] отвечает с host?       нет:Connection refused

    ДИАГНОЗ:  работает внутри, недоступен снаружи
    РАЗДЕЛ:   3.1 и 3.6
    ДАЛЬШЕ:   проверить привязку: слушает ли 0.0.0.0, а не 127.0.0.1

  ── убит командой kill ──
  Диагностика: t-killed

    [1] container создан?      да
    [2] статус?                exited (код 137, перезапусков 0)

    ДИАГНОЗ:  SIGKILL извне; возможен OOM на уровне host
    РАЗДЕЛ:   1.3
    ДАЛЬШЕ:   sudo dmesg -T | grep -i 'killed process'

    различных диагнозов на четыре неисправности: 4
  ✓ каждая неисправность получила свой диагноз и раздел таблицы

═══ Требование 4: один код 137 — разные диагнозы ═══
    container      код    OOMKilled   диагноз
    ──────────────────────────────────────────────────────────────────────────
    t-oom          137    true        убит по нехватке памяти в cgroup
    t-killed       137    false       SIGKILL извне; возможен OOM на уровне ho
  ✓ одинаковый код 137 разведён на два диагноза

═══ Требование 5: исправный сервис ═══
  Диагностика: t-good

    [1] container создан?      да
    [2] статус?                running (код 0, перезапусков 0)
    [3] строк в логах?         1
    [4] проверка здоровья?     нет
    [5] отвечает изнутри?      да
    [6] отвечает с host?       да

    ДИАГНОЗ:  сервис работает и доступен снаружи
    РАЗДЕЛ:   —
    ДАЛЬШЕ:   проблем не обнаружено

    код возврата: 0
  ✓ на исправном сервисе ложного диагноза нет (код 0)

═══ Требование 6: непроверенное отличается от пройденного ═══
    [5] отвечает изнутри?      ПРОВЕРКА НЕ ВЫПОЛНЕНА (нет python в образе)
    ДИАГНОЗ:  шаг 5 не выполнен — инструмент недоступен в образе
  ✓ шаг, который не удалось выполнить, помечен явно, а не засчитан

═══ Проверка остановки на первом отрицательном ответе ═══
    шагов пройдено на упавшем: 2
    шагов пройдено на исправном: 6
  ✓ инструмент останавливается на первом отрицательном ответе

═══ ИТОГ ═══
  все требования выполнены