Ceph - defragment OSD

Check for score:

ceph daemon osd.0 bluestore allocator score block

Deframgment:

YES=1 THRESHOLD=0.80 POLL=5 MAX_WAIT=172800 bash <<'BASH'
set -Eeuo pipefail

# THRESHOLD – minimalny fragmentation_rating
# POLL      – odstęp sprawdzania w sekundach
# MAX_WAIT  – maksymalny czas jednego oczekiwania; 0 = bez limitu
: "${THRESHOLD:=0.80}"
: "${POLL:=3}"
: "${MAX_WAIT:=172800}"
: "${CMD_TIMEOUT:=60}"
: "${YES:=0}"

for cmd in ceph jq awk sort timeout; do
    command -v "$cmd" >/dev/null || {
        echo "Brakuje programu: $cmd" >&2
        exit 1
    }
done

CURRENT_OSD=""
CURRENT_OUT=0
SCORES_FILE="$(mktemp)"

cleanup() {
    rc=$?

    if [[ -n "$CURRENT_OSD" && "$CURRENT_OUT" == "1" ]]; then
        echo
        echo "UWAGA: skrypt przerwany podczas obsługi osd.${CURRENT_OSD}."
        echo "Przywracam osd.${CURRENT_OSD} do stanu in..."
        ceph osd in "osd.${CURRENT_OSD}" || true
    fi

    rm -f "$SCORES_FILE"
    trap - EXIT INT TERM
    exit "$rc"
}
trap cleanup EXIT INT TERM

score_osd() {
    local id="$1"
    local output score

    output="$(
        timeout "$CMD_TIMEOUT" \
            ceph -f json tell "osd.${id}" \
            bluestore allocator score block 2>/dev/null
    )" || return 1

    score="$(
        jq -r '
            .. | objects |
            .fragmentation_rating? // empty
        ' <<<"$output" | head -n1
    )"

    [[ "$score" =~ ^[0-9]+([.][0-9]+)?$ ]] || return 1
    printf '%s\n' "$score"
}

cluster_clean() {
    local status total clean

    status="$(ceph -s -f json 2>/dev/null)" || return 1

    total="$(jq -r '.pgmap.num_pgs // 0' <<<"$status")"
    clean="$(
        jq -r '
            [
                .pgmap.pgs_by_state[]?
                | select(.state_name == "active+clean")
                | .count
            ] | add // 0
        ' <<<"$status"
    )"

    [[ "$total" -gt 0 && "$clean" -eq "$total" ]]
}

osd_safe_to_destroy() {
    ceph osd safe-to-destroy "osd.${CURRENT_OSD}" >/dev/null 2>&1
}

osd_up_and_in() {
    ceph osd dump -f json 2>/dev/null |
        jq -e --argjson id "$CURRENT_OSD" '
            any(
                .osds[];
                .osd == $id and .up == 1 and .in == 1
            )
        ' >/dev/null
}

wait_until() {
    local description="$1"
    local check_function="$2"
    local started now elapsed

    started="$(date +%s)"

    while ! "$check_function"; do
        now="$(date +%s)"
        elapsed=$((now - started))

        if (( MAX_WAIT > 0 && elapsed >= MAX_WAIT )); then
            echo "TIMEOUT po ${elapsed}s: ${description}" >&2
            return 1
        fi

        echo
        echo "[$(date '+%F %T')] Czekam: ${description}; upłynęło ${elapsed}s"
        ceph -s || true
        sleep "$POLL"
    done

    echo "[$(date '+%F %T')] Gotowe: ${description}"
}

echo "Sprawdzam stan klastra..."

ceph -s

if ! cluster_clean; then
    echo
    echo "Cluster nie ma wszystkich PG w stanie active+clean."
    echo "Przerywam bez dokonywania zmian."
    exit 1
fi

FLAGS="$(ceph osd dump -f json | jq -r '.flags // ""')"

for flag in noout nobackfill norecover norebalance pause; do
    if [[ ",${FLAGS// /}," == *",${flag},"* ]]; then
        echo "Aktywna flaga OSD blokująca operację: ${flag}" >&2
        exit 1
    fi
done

echo
echo "Fragmentacja OSD:"

mapfile -t OSD_IDS < <(
    ceph osd dump -f json |
        jq -r '
            .osds[]
            | select(.up == 1 and .in == 1)
            | .osd
        ' |
        sort -n
)

for id in "${OSD_IDS[@]}"; do
    if score="$(score_osd "$id")"; then
        printf '  osd.%-4s %s\n' "$id" "$score"

        if awk -v score="$score" -v threshold="$THRESHOLD" \
            'BEGIN { exit !(score >= threshold) }'
        then
            printf '%s\t%s\n' "$score" "$id" >>"$SCORES_FILE"
        fi
    else
        echo "  osd.${id}  BŁĄD ODCZYTU"
    fi
done

mapfile -t CANDIDATES < <(
    sort -nr -k1,1 "$SCORES_FILE" | awk '{print $2}'
)

if (( ${#CANDIDATES[@]} == 0 )); then
    echo
    echo "Brak OSD z fragmentation_rating >= ${THRESHOLD}."
    exit 0
fi

echo
echo "OSD przeznaczone do przebudowania, od najwyższego wyniku:"
sort -nr -k1,1 "$SCORES_FILE" |
    awk '{printf "  osd.%-4s score=%s\n", $2, $1}'

if [[ "$YES" != "1" ]]; then
    echo
    read -r -p 'Wpisz dokładnie YES, aby rozpocząć: ' answer
    [[ "$answer" == "YES" ]] || {
        echo "Anulowano."
        exit 1
    }
fi

for id in "${CANDIDATES[@]}"; do
    CURRENT_OSD="$id"

    # Wynik mógł zmienić się podczas obsługi wcześniejszych OSD.
    if ! current_score="$(score_osd "$id")"; then
        echo "Nie udało się ponownie odczytać osd.${id}; pomijam."
        CURRENT_OSD=""
        continue
    fi

    if ! awk -v score="$current_score" -v threshold="$THRESHOLD" \
        'BEGIN { exit !(score >= threshold) }'
    then
        echo
        echo "Pomijam osd.${id}: aktualny score=${current_score}, próg=${THRESHOLD}."
        CURRENT_OSD=""
        continue
    fi

    echo
    echo "============================================================"
    echo "osd.${id}: rozpoczęcie, fragmentation_rating=${current_score}"
    echo "============================================================"

    wait_until \
        "cluster active+clean przed wyłączeniem osd.${id}" \
        cluster_clean

    echo "Oznaczam osd.${id} jako out..."
    ceph osd out "osd.${id}"
    CURRENT_OUT=1

    wait_until \
        "osd.${id} safe-to-destroy, czyli całkowicie opróżniony" \
        osd_safe_to_destroy

    wait_until \
        "cluster active+clean po opróżnieniu osd.${id}" \
        cluster_clean

    echo "Oznaczam osd.${id} jako in..."
    ceph osd in "osd.${id}"
    CURRENT_OUT=0

    wait_until \
        "osd.${id} up oraz in" \
        osd_up_and_in

    wait_until \
        "pełne active+clean po ponownym włączeniu osd.${id}" \
        cluster_clean

    sleep "$POLL"

    if new_score="$(score_osd "$id")"; then
        echo "osd.${id}: fragmentacja przed=${current_score}, po=${new_score}"
    else
        echo "osd.${id}: zakończono, ale nie udało się odczytać nowego wyniku."
    fi

    CURRENT_OSD=""
done

echo
echo "Wszystkie wybrane OSD zostały przetworzone."
ceph -s

echo
echo "Końcowy stan fragmentacji OSD:"
echo

mapfile -t FINAL_OSD_IDS < <(
    ceph osd dump -f json |
        jq -r '
            .osds[]
            | select(.up == 1 and .in == 1)
            | .osd
        ' |
        sort -n
)

FINAL_READ_ERRORS=0
FINAL_ABOVE_THRESHOLD=0

for id in "${FINAL_OSD_IDS[@]}"; do
    if score="$(score_osd "$id")"; then
        status="OK"

        if awk -v score="$score" -v threshold="$THRESHOLD" \
            'BEGIN { exit !(score >= threshold) }'
        then
            status="NADAL >= ${THRESHOLD}"
            FINAL_ABOVE_THRESHOLD=$((FINAL_ABOVE_THRESHOLD + 1))
        fi

        printf '  osd.%-4s fragmentation_rating=%-8s %s\n' \
            "$id" "$score" "$status"
    else
        printf '  osd.%-4s BŁĄD ODCZYTU\n' "$id"
        FINAL_READ_ERRORS=$((FINAL_READ_ERRORS + 1))
    fi
done

echo
echo "Podsumowanie końcowe:"
echo "  OSD up+in:                         ${#FINAL_OSD_IDS[@]}"
echo "  OSD z wynikiem >= ${THRESHOLD}:          ${FINAL_ABOVE_THRESHOLD}"
echo "  Błędy odczytu:                     ${FINAL_READ_ERRORS}"

if (( FINAL_ABOVE_THRESHOLD == 0 && FINAL_READ_ERRORS == 0 )); then
    echo "  Wynik: wszystkie OSD są poniżej ustawionego progu."
elif (( FINAL_ABOVE_THRESHOLD > 0 )); then
    echo "  Wynik: część OSD nadal przekracza ustawiony próg."
else
    echo "  Wynik: nie można jednoznacznie ocenić wszystkich OSD."
fi
BASH