Архивирование системы

[ROOT]

Унифицированная система резервного копирования и восстановления систем

system-backup.sh — это инструмент полного резервного копирования и восстановления Linux-систем (Fedora / CentOS / Alma / Rocky и др.) на основе tar-архивов.

Скрипт предназначен для:

• создания консистентных архивов системных разделов
• восстановления системы на новый диск
• разметки и форматирования диска
• проверки доступных бэкапов
• работы как в LIVE-режиме, так и в rescue-среде

Поддерживаемые разделы
Скрипт работает с фиксированным набором разделов:

• efi
• boot
• rootfs
• home
• var
• swap

Фактический порядок обработки задаётся внутри скрипта массивом PARTS_ORDER и гарантированно соблюдается как при создании, так и при восстановлении архивов.

Режимы работы

• LIVE (multi-user.target)
  Работа в запущенной системе.
  Корневой раздел уже смонтирован, архивирование выполняется «на горячую».
• OFFLINE / RESCUE
  Работа из rescue-режима или Live-носителя.
  Разделы монтируются вручную в $SYS_DIR, после чего производится восстановление.

Режим определяется автоматически через systemctl get-default.

Основные параметры

• -b —Создание бэкапа
• -r — Восстановление системы
• -c — Разметка и форматирование диска
• -i — Информация о доступных бэкапах
• -v — Проверка целостности последнего архива
• -V — Проверка целостности всех бэкапов
• -h — Справка

Архивирование
При создании бэкапа:

• Для каждого раздела создаётся отдельный tar-архив.
• Архивы размещаются в каталоге вида: /mnt/BACKUP/<HOST>/<DATE_TIME>
• Используется последовательная обработка разделов согласно PARTS_ORDER.

Если раздел отсутствует или не смонтирован — выводится предупреждение, но скрипт продолжает выполнение.

Восстановление
Процесс восстановления включает:

• Разметку диска (если выбран режим -m)
• Форматирование файловых систем
• Монтирование разделов
• Распаковку архивов в установленном порядке
• Установку и конфигурацию загрузчика
• Восстановление SELinux-контекстов

После восстановления выполняется:

Код: выделить все

restorecon -Rv /

для корректного применения контекстов безопасности.
Особенности chroot
При работе в rescue-режиме:

• Временная корректировка /etc/resolv.conf внутри chroot для обеспечения работы dnf и сетевых операций.
• После завершения конфигурации оригинальное состояние восстанавливается.

MAKE_PART (разметка диска)
Функция разметки:

• использует parted
• создаёт таблицу разделов
• форматирует разделы через mkfs.*
• создаёт swap при необходимости

Конкретные файловые системы и layout задаются переменными внутри скрипта.
Логирование

Скрипт реализует многоуровневое логирование:

• START / END сессии
• INFO / WARN / ERROR
• лог-файл
• вывод в консоль
• поддержка syslog

Особенности:

• Корректная обработка Ctrl+C (INT)
• Обработка SIGTERM
• Гарантированное завершение сессии через trap EXIT
• Отсутствие дублирования END-блока
• Восстановление состояния терминала (stty echoctl)

При запуске с -h лог-сессия не активируется.

Обработка прерываний

• Ctrl+C → статус FAILED
• штатное завершение → статус SUCCESS
• исключены двойные вызовы log_session_end
• корректное восстановление терминала

Поведение при неполных бэкапах
Если какой-либо архив отсутствует:

• выводится предупреждение
• процесс продолжается
• критическая ошибка возникает только при невозможности восстановления ключевых разделов

Требования

• bash 4+
• tar
• parted
• mkfs.*
• grub2
• systemd
• restorecon (SELinux)

Назначение
Скрипт предназначен для:

• быстрого переноса системы на новый диск
• восстановления после сбоя
• создания аварийных бэкапов
• администрирования Fedora-подобных систем

Не является snapshot-решением (не LVM snapshot и не btrfs snapshot).

[ROOT]

1. Стабилизация функции восстановления в процессе
2. Все остальные функции работают

Код: выделить все

#!/bin/bash
############################################################
# system-backup.sh — Инструмент резервного копирования
# Linux-подобных систем методом архивирования полного набора
# файлов с существующих файловых систем.
#
#
# Режимы работы:
#   - LIVE  (работа на запущенной системе)
#   - OFFLINE / RESCUE (восстановление из внешней среды)
#
# ВНИМАНИЕ: операции восстановления и разметки уничтожают данные.
#
# Версия: 6.0
# Автор: SSERGEY + GPT
# Дата: 2026-01-26
# Проект: https://forum.free-adm.ru/viewtopic.php?f=16&t=391
############################################################

set -euo pipefail

###############################
### === CONFIGURATION === ###
###############################
SYS_DEV="/dev/sda"              # системный диск (подменяй при необходимости)
SYS_DIR="/mnt/fedora"              # точка монтирования для оффлайн
BACKUP_ROOT="/mnt/BACKUP/FEDORA"   # корень хранения бэкапов
TYPEFS="-t xfs"                    # используемый тип при монтировании rootfs
DATE=$(date +%d-%m-%Y)
BACKUP_PATH="${BACKUP_ROOT}/${DATE}_$(date +%H-%M)"
ME=$(basename "$0")
VERSION="6.0"
MODE=""   # ARCHIVE | RESTORE ...
STATUS="SUCCESS"
LOG_SESSION_STARTED=false
# флаг, чтобы не вызывать log_session_end дважды
LOG_SESSION_ENDED=false
# Скрываем ^C в терминале
stty -echoctl

NO_ICONS=false

OK_ICON=$'\u2713'
WARN_ICON='!'
ERR_ICON=$'\u2717'
INFO_ICON=$'\u2192'
SKIP_ICON=$'\u2026'
DEBUG_ICON=$'\U0001F6E0'

# Семантические разделители
ARROW=$'\u2192'
ELLIPSIS=$'\u2026'

EXCLUDES=(
  '/proc/*' '/sys/*' '/dev/*' '/run/*' '/mnt/*/*' '/media/*' '/tmp/*' '/var/tmp/*'
  './proc/*' './sys/*' './dev/*' './run/*' './mnt/*/*' './media/*' './tmp/*' './var/tmp/*'
)

# число последних бэкапов, которые храним
KEEP_COUNT=5
COMPRESSOR_DEFAULT="xz -T0 -1"

declare -A FSTYPES=(
  [efi]="vfat"
  [boot]="xfs"
  [rootfs]="xfs"
  [home]="xfs"
  [var]="xfs"
  [swap]="swap"
)

###############################
### === ПРОФЕССИОНАЛЬНОЕ ЛОГИРОВАНИЕ === ###
###############################
# Уровни логирования
LOG_LEVEL=3  # 1=ERROR, 2=WARN, 3=INFO, 4=DEBUG
USE_SYSLOG=true
LOG_FILE="${BACKUP_ROOT}/system-backup.log"

function _log() {
    local level="$1"; shift
    local message="$*"
    local timestamp
    timestamp="$(date '+%Y-%m-%d %H:%M:%S')"

    local level_num level_tag color_reset color_tag
    case "$level" in
        ERROR) level_num=1; level_tag="${ERR_ICON} ERROR"; color_tag="\033[1;31m" ;; # red
        WARN)  level_num=2; level_tag="${WARN_ICON} WARN "; color_tag="\033[1;33m" ;; # yellow
        INFO)  level_num=3; level_tag="${INFO_ICON} INFO "; color_tag="\033[1;34m" ;; # blue
        OK)    level_num=3; level_tag="${OK_ICON} OK   ";  color_tag="\033[1;32m" ;; # green
        DEBUG) level_num=4; level_tag="${DEBUG_ICON} DEBUG"; color_tag="\033[0;90m" ;; # gray
        *)     level_num=3; level_tag="INFO"; color_tag="\033[0m" ;;
    esac

    color_reset="\033[0m"

    # Пишем в лог-файл без цветов
    echo "[$timestamp] [$level_tag] $message" >> "$LOG_FILE"

    # Если уровень логирования достаточный — выводим на экран (только если есть TTY)
    if (( level_num <= LOG_LEVEL )) && [[ -t 1 ]]; then
        echo -e "${color_tag}[$timestamp] [$level_tag]${color_reset} $message"
    elif (( level_num <= LOG_LEVEL )); then
        # Если нет TTY (cron и т.д.), выводим без цветов
        echo "[$timestamp] [$level_tag] $message"
    fi

    # Отправляем в syslog (опционально)
    if [[ "$USE_SYSLOG" == true ]] && (( level_num <= 3 )); then # ERROR, WARN, INFO только
        logger -t "system-backup" "[$level_tag] $message"
    fi
}

# Удобные обёртки
log_info()  { _log INFO  "$@"; }
log_warn()  { _log WARN  "$@"; }
log_error() { _log ERROR "$@"; }
log_ok()    { _log OK    "$@"; }
log_debug() { _log DEBUG "$@"; }

log_session_start() {
    LOG_SESSION_STARTED=true
    local ts
    ts="$(date '+%Y-%m-%d %H:%M:%S')"

    local title="START | MODE: $MODE | VERSION: $VERSION"
    local line_width=63  # длина линии с '=' сверху и снизу
    local title_len=${#title}
    local pad_total=$(( line_width - title_len ))
    local pad_left=$(( pad_total / 2 ))
    local pad_right=$(( pad_total - pad_left ))

    # Строка с '=' сверху
    printf '=%.0s' $(seq 1 $line_width) >> "$LOG_FILE"; echo >> "$LOG_FILE"
    # Центральная строка с пробелами слева и справа
    printf '%*s%s%*s\n' "$pad_left" '' "$title" "$pad_right" '' >> "$LOG_FILE"
    # Строка с '=' снизу
    printf '=%.0s' $(seq 1 $line_width) >> "$LOG_FILE"; echo >> "$LOG_FILE"

    # Вывод на экран
    if [[ -t 1 ]]; then
        printf '=%.0s' $(seq 1 $line_width); echo
        printf '%*s%s%*s\n' "$pad_left" '' "$title" "$pad_right" ''
        printf '=%.0s' $(seq 1 $line_width); echo
        echo
    fi
}

# Функция для логирования заголовков разделов
log_header() {
    local text="$1"
    local width=63
    local pad char

    char="="

    # Убираем возможные лишние пробелы
    text="$(echo "$text" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')"

    local text_len=${#text}
    local pad_total=$(( width - text_len - 2 ))
    (( pad_total < 0 )) && pad_total=0

    local pad_left=$(( pad_total / 2 ))
    local pad_right=$(( pad_total - pad_left ))

    printf "%s %s %s\n\n" \
        "$(printf "%*s" "$pad_left" "" | tr ' ' "$char")" \
        "$text" \
        "$(printf "%*s" "$pad_right" "" | tr ' ' "$char")"
}

log_separator() {
    echo >> "$LOG_FILE"
    if [[ -t 1 ]]; then
        echo
    fi
}

log_session_end() {
    local status="$1"   # SUCCESS | FAILED
    local ts
    ts="$(date '+%Y-%m-%d %H:%M:%S')"

    local title="END | STATUS: $status"
    local line_width=63
    local title_len=${#title}
    local pad_total=$(( line_width - title_len ))
    local pad_left=$(( pad_total / 2 ))
    local pad_right=$(( pad_total - pad_left ))

    # В лог-файл
    echo >> "$LOG_FILE"
    printf '=%.0s' $(seq 1 $line_width) >> "$LOG_FILE"; echo >> "$LOG_FILE"
    printf '%*s%s%*s\n' "$pad_left" '' "$title" "$pad_right" '' >> "$LOG_FILE"
    printf '=%.0s' $(seq 1 $line_width) >> "$LOG_FILE"; echo >> "$LOG_FILE"
    echo >> "$LOG_FILE"

    # Вывод на экран
    if [[ -t 1 ]]; then
        echo
        printf '=%.0s' $(seq 1 $line_width); echo
        printf '%*s%s%*s\n' "$pad_left" '' "$title" "$pad_right" ''
        printf '=%.0s' $(seq 1 $line_width); echo
        echo
    fi
}

# ловим Ctrl+C и SIGTERM
trap 'STATUS="FAILED";
      [[ "$LOG_SESSION_ENDED" == false ]] && log_session_end "$STATUS";
      LOG_SESSION_ENDED=true;
      exit 1' INT TERM

# ловим EXIT
trap 'stty echoctl
if [[ "$LOG_SESSION_STARTED" == true && "$LOG_SESSION_ENDED" == false ]]; then
    log_session_end "$STATUS"
    LOG_SESSION_ENDED=true
fi
' EXIT

###############################
### === MODE DETECTION === ###
###############################
detect_mode_and_print_info() {
    log_header "СИСТЕМА РЕЗЕРВНОГО КОПИРОВАНИЯ"

    DEFAULT_TARGET=$(systemctl get-default 2>/dev/null || echo "N/A")
    ACTIVE_TARGET=$(systemctl list-units --type=target --state=active --no-legend | awk '{print $1}' | tr '\n' ' ')
    IS_ISOLATED=false
    if echo "$ACTIVE_TARGET" | grep -q "rescue.target" && [[ "$DEFAULT_TARGET" != "rescue.target" ]]; then
        IS_ISOLATED=true
    fi

    case "$DEFAULT_TARGET" in
        graphical.target) MODE="ЖИВАЯ (graphical.target)" ;;
        multi-user.target) MODE="ЖИВАЯ (multi-user.target)" ;;
        rescue.target) MODE="RESCUE (загрузка в rescue.target)" ;;
        emergency.target) MODE="EMERGENCY (минимальный)" ;;
        *) MODE="ОФФЛАЙН / внешняя система" ;;
    esac
    [[ "$IS_ISOLATED" == "true" ]] && MODE="${MODE} (ISOLATED)"

    log_info "Скрипт: $ME"
    log_info "Системный диск: $SYS_DEV"
    log_info "Каталог бэкапа: $BACKUP_PATH"
    log_info "Режим архивации: $MODE"
}
###############################
### === HELPERS / FUNCs === ###
###############################
# PARTS in guaranteed order
function SET_PARTS() {
    PARTS_ORDER=(efi boot home var)

    declare -gA PARTS=(
        [efi]="$SYS_DIR/boot/efi"
        [boot]="$SYS_DIR/boot"
        [home]="$SYS_DIR/home"
        [var]="$SYS_DIR/var"
        [rootfs]="$SYS_DIR"
    )
}

# === Проверка окружения BACKUP и SYS_DEV ===
function CHECK_BACKUP_ENV() {
  log_header "ПРОВЕРКА BACKUP ОКРУЖЕНИЯ"

  # 1. Проверка системного устройства
  if [[ -z "${SYS_DEV:-}" ]]; then
    log_error "Переменная SYS_DEV не установлена!"
    exit 1
  fi
  if [[ ! -b "$SYS_DEV" ]]; then
    log_error "Устройство $SYS_DEV не существует или не является блочным."
    exit 1
  fi
  log_ok "Системное устройство: $SYS_DEV"

  # 2. Проверка каталога BACKUP_ROOT
  if [[ -z "${BACKUP_ROOT:-}" ]]; then
    log_error "Переменная BACKUP_ROOT не установлена!"
    exit 1
  fi
  if [[ ! -d "$BACKUP_ROOT" ]]; then
    log_error "Каталог ${BACKUP_ROOT} не найден!"
    exit 1
  fi

  # 3. Проверяем, смонтирован ли BACKUP_ROOT или его родитель
  if mountpoint -q "$BACKUP_ROOT"; then
    local backup_dev
    backup_dev=$(findmnt -n -o SOURCE "$BACKUP_ROOT" 2>/dev/null)
    log_ok "BACKUP смонтирован с устройства: ${backup_dev}"

    # 3a. Проверяем, не находится ли BACKUP на системном диске
    if [[ "$backup_dev" == "$SYS_DEV"* ]]; then
      log_error "${SYS_DEV} используется как BACKUP-диск (${BACKUP_ROOT})!"
      log_warn "Это приведёт к циклическому архивированию."
      exit 1
    fi

  # если не смонтирован сам BACKUP_ROOT, проверяем родитель
  elif mountpoint -q "$(dirname "$BACKUP_ROOT")"; then
    local parent_dev
    parent_dev=$(findmnt -n -o SOURCE "$(dirname "$BACKUP_ROOT")" 2>/dev/null)
    log_info "${BACKUP_ROOT} — подкаталог смонтированной точки $(dirname "$BACKUP_ROOT") (${parent_dev})"

    if [[ "$parent_dev" == "$SYS_DEV"* ]]; then
      log_error "${SYS_DEV} используется как BACKUP-диск (через родительскую точку $(dirname "$BACKUP_ROOT"))!"
      log_warn "Это приведёт к циклическому архивированию."
      exit 1
    fi

  else
    log_warn "${BACKUP_ROOT} не смонтирован (и родитель тоже не смонтирован)!"
  fi

  # 4. Проверяем, что BACKUP_ROOT не находится внутри SYS_DIR (например /mnt/BACKUP при SYS_DIR=/)
  if [[ -n "${SYS_DIR:-}" && "$BACKUP_ROOT" == "$SYS_DIR"* ]]; then
    log_error "BACKUP_ROOT (${BACKUP_ROOT}) находится внутри SYS_DIR (${SYS_DIR})!"
    log_warn "Это приведёт к самосохранению архива в себя."
    exit 1
  fi

  log_ok "Проверка окружения завершена успешно."
}

# select best compressor based on BACKUP mount device type
function SELECT_COMPRESSOR() {
  local src parent disk rota bin
  src=$(findmnt -n -o SOURCE --target "${BACKUP_ROOT}" 2>/dev/null || true)
  if [[ -z "$src" ]]; then
    COMPRESSOR="${COMPRESSOR_DEFAULT}"
    log_warn "Не удалось определить устройство BACKUP; выбран дефолт: ${COMPRESSOR}"
    return
  fi

  parent=$(lsblk -no PKNAME "$src" 2>/dev/null || basename "$(readlink -f "$src")" | sed -E 's/p?[0-9]+$//')
  [[ -z "$parent" ]] && { COMPRESSOR="${COMPRESSOR_DEFAULT}"; return; }
  disk="/dev/${parent}"
  rota=$(lsblk -dn -o ROTA "$disk" 2>/dev/null || echo "")

  if [[ "$rota" == "1" ]]; then
    if command -v zstd &>/dev/null; then
      COMPRESSOR="zstd -T0 -6"
      bin="zstd"
    else
      COMPRESSOR="xz -T0 -1"
      bin="xz"
    fi
    log_info "BACKUP HDD ${ARROW} компрессор: ${COMPRESSOR}"
  else
    if command -v zstd &>/dev/null; then
      COMPRESSOR="zstd -T0 -9"
      bin="zstd"
    elif command -v xz &>/dev/null; then
      COMPRESSOR="xz -T0 -1"
      bin="xz"
    else
      COMPRESSOR="${COMPRESSOR_DEFAULT}"
      bin="$(echo ${COMPRESSOR} | awk '{print $1}')"
    fi
    log_info "BACKUP SSD/NVMe ${ARROW} компрессор: ${COMPRESSOR}"
  fi

  # финальная проверка что выбранный бинарник существует
  if ! command -v "${bin}" &>/dev/null; then
    log_warn "Выбранный компрессор '${bin}' не найден — откат на ${COMPRESSOR_DEFAULT}"
    COMPRESSOR="${COMPRESSOR_DEFAULT}"
  fi
}


# обнаружение имен разделов по меткам (с максимальной точностью)
function DETECT_PARTS_LABELS() {
  ROOT_PART=$(lsblk -lno NAME,PARTLABEL | awk '/RootFS/{print "/dev/"$1}' || true)
  BOOT_PART=$(lsblk -lno NAME,PARTLABEL | awk '/Boot/{print "/dev/"$1}' || true)
  EFI_PART=$(lsblk -lno NAME,PARTLABEL | awk '/EFI/{print "/dev/"$1}' || true)
  HOME_PART=$(lsblk -lno NAME,PARTLABEL | awk '/Homes/{print "/dev/"$1}' || true)
  VAR_PART=$(lsblk -lno NAME,PARTLABEL | awk '/Var/{print "/dev/"$1}' || true)
}

# монтировать системные разделы (работает для live/rescue/offline)
function MOUNT_SYS() {
  DETECT_PARTS_LABELS

  # решаем: живой режим или оффлайн (попробуем быть максимально аккуратными)
  if mountpoint -q / && [[ "$(findmnt -n -o TARGET /)" == "/" ]]; then
    log_info "Работаем в ЖИВОЙ системе (root смонтирован)"
    LIVE_MODE=true
    SYS_DIR="/"
  else
    log_info "Работаем в ОФФЛАЙН режиме — монтируем root (${SYS_DIR})"
    local rp="${ROOT_PART:-${SYS_DEV}p3}"

    # Создаем только если каталога нет
    [[ -d "${SYS_DIR}" ]] || mkdir -p "${SYS_DIR}"

    mount ${TYPEFS} "${rp}" "${SYS_DIR}" || { log_error "Ошибка монтирования RootFS (${rp})"; exit 1; }
    LIVE_MODE=false
  fi

  # сформируем PARTS и порядок
  SET_PARTS

  # Монтируем дополнительные точки ТОЛЬКО если:
  #  - мы в оффлайн-режиме (мы сами монтировали root), или
  #  - точка ожидается, но не смонтирована (на живой системе)
  suffix=""; [[ "${SYS_DEV}" =~ (nvme|mmcblk) ]] && suffix="p"
  for key in "${PARTS_ORDER[@]}"; do
    local mount_point
    mount_point=$(realpath -m "${PARTS[$key]}")
    # normalize root rep
    [[ "$mount_point" == "//" ]] && mount_point="/"

    # не пытаемся монтировать сам корень если он уже /
    if [[ "$mount_point" == "/" ]]; then
      continue
    fi

    if mountpoint -q "${mount_point}"; then
      log_ok "${mount_point} уже смонтирован."
      continue
    fi

    # если мы в live режиме и точка не смонтирована — НЕ монтируем автоматически (опасно)
    if [[ "${LIVE_MODE}" == "true" && ! -b "${mount_point}" ]]; then
      log_warn "${mount_point} не смонтирована в живой системе — пропускаем."
      continue
    fi

    # в оффлайн: монтируем по ожидаемому устройству (если есть)
    if [[ "${LIVE_MODE}" == "false" ]]; then
      mkdir -p "${mount_point}"
      case "$key" in
        efi) part="${EFI_PART:-${SYS_DEV}${suffix}1}" ;;
        boot) part="${BOOT_PART:-${SYS_DEV}${suffix}2}" ;;
        rootfs) part="${ROOT_PART:-${SYS_DEV}${suffix}3}" ;;
        home) part="${HOME_PART:-${SYS_DEV}${suffix}4}" ;;
        var) part="${VAR_PART:-${SYS_DEV}${suffix}5}" ;;
        *) part="" ;;
      esac

      if [[ -n "${part}" && -b "${part}" ]]; then
        log_info "Монтируем ${part} ${ARROW} ${mount_point}"
        mount "${part}" "${mount_point}" 2>/dev/null \
          && log_ok "Успешно смонтирован ${mount_point}" \
          || log_warn "Не удалось смонтировать ${mount_point} (источник: ${part})"
      else
        log_warn "Источник для ${mount_point} не найден — пропускаем."
      fi
    fi
  done
}

# отмонтировать (только если мы монтировали)
function UMOUNT_SYS() {
  if [[ "${LIVE_MODE:-false}" == "true" ]]; then
    log_warn "Живая система — автоматическое размонтирование не выполняется."
  else
    log_info "Размонтируем ${SYS_DIR}${ELLIPSIS}"
    umount -R "${SYS_DIR}" 2>/dev/null || log_warn "Некоторые точки не размонтировались."
  fi
}

###############################
### === CREATE BACKUP === ###
###############################
function CREATE_TAR() {
  START_TIME=$(date +%s)

  # Создаём каталог для логов только при реальном бэкапе
  mkdir -p "${BACKUP_PATH}" 2>/dev/null || true

  CHECK_BACKUP_ENV
  MOUNT_SYS
  SET_PARTS
  SELECT_COMPRESSOR

  log_header "СОЗДАНИЕ РЕЗЕРВНЫХ АРХИВОВ"

  EXCLUDE_ARGS=()
  for e in "${EXCLUDES[@]}"; do EXCLUDE_ARGS+=(--exclude="$e"); done

  log_info "Архивирование (компрессор: ${COMPRESSOR})${ELLIPSIS}"

  # Определяем реальные точки монтирования и флаги для каждой файловой системы
  declare -A REAL_PARTS=()
  declare -A TAR_OPTS=()

  for part in efi boot rootfs home var; do
      SRC="${PARTS[$part]}"

      # Получаем тип файловой системы для текущей точки монтирования
      FSTYPE=$(df -T "$SRC" | awk 'NR==2 {print $2}')

      # Назначаем соответствующие флаги для tar в зависимости от типа файловой системы
      case "$FSTYPE" in
        xfs)
          TAR_OPTS["$part"]="--xattrs --acls --selinux --one-file-system --warning=no-file-changed --warning=no-file-ignored --ignore-failed-read"
          ;;
        vfat)
          TAR_OPTS["$part"]="--xattrs --acls --one-file-system --warning=no-file-changed --warning=no-file-ignored --ignore-failed-read"
          ;;
        ext4)
          TAR_OPTS["$part"]="--xattrs --acls --selinux --one-file-system --warning=no-file-changed --warning=no-file-ignored --ignore-failed-read"
          ;;
        *)
          TAR_OPTS["$part"]="--xattrs --acls --one-file-system --warning=no-file-changed --warning=no-file-ignored --ignore-failed-read"
          ;;
      esac

      # Если раздел смонтирован, добавляем его в список
      if mountpoint -q "$SRC"; then
          REAL_PARTS["$part"]="$SRC"
      else
          SRC=$(echo "$SRC" | sed -E 's#//+#/#g')
          log_warn "${SRC} не является отдельной файловой системой — пропускаем."
      fi
  done

  # Итерация по массиву с гарантированным порядком
  for part in "${PARTS_ORDER[@]}"; do
      SRC="${REAL_PARTS[$part]:-}"

      # Пропускаем, если раздел не найден
      [[ -z "$SRC" ]] && continue

      # Нормализация путей, чтобы не было //boot и т.п.
      SRC=$(echo "$SRC" | sed -E 's#//+#/#g')

      # Красивый визуальный разделитель для логов
      log_header "АРХИВИРОВАНИЕ ${part^^}"

      # Генерация архива
      ARC="${BACKUP_PATH}/${part}.tar"
      log_info "${SRC} ${ARROW} ${ARC}.${COMPRESSOR%% *}"

      if [[ -d "$SRC" ]]; then
          # Выбираем правильные флаги для данного типа файловой системы
          TAR_FLAGS="${TAR_OPTS[$part]}"

          tar -cpf - $TAR_FLAGS \
              "${EXCLUDE_ARGS[@]}" -C "${SRC}" . \
          | ${COMPRESSOR} > "${ARC}.tmp" \
          && mv -f "${ARC}.tmp" "${ARC}.${COMPRESSOR%% *}" \
          || { log_error "Ошибка архивирования ${part}"; rm -f "${ARC}.tmp"; UMOUNT_SYS; exit 1; }
          log_ok "Успешно заархивирован ${part}"
      else
          log_warn "Пропуск: ${SRC} не найден."
      fi
  done

  log_header "КОНТРОЛЬНЫЕ СУММЫ SHA256"
  (cd "${BACKUP_PATH}" && sha256sum *tar.* | tee -a "$LOG_FILE" > "${BACKUP_PATH}/checksums.sha256")
  log_ok "Контрольные суммы сохранены."

  log_header "ОЧИСТКА СТАРЫХ БЭКАПОВ"
  if [[ "$KEEP_COUNT" -gt 0 ]]; then
    total=$(ls -1dt "${BACKUP_ROOT}"/*/ 2>/dev/null | wc -l)
    if (( total > KEEP_COUNT )); then
      remove=$(( total - KEEP_COUNT ))
      log_warn "Удаляем старые копии, оставляем ${KEEP_COUNT}:"
      ls -1dt "${BACKUP_ROOT}"/*/ | tail -n "$remove" | while read -r old; do
        log_info "Удаляем: ${old}"
        rm -rf "${old}"
      done
    else
      log_info "Очистка не требуется — ${total} копий ≤ ${KEEP_COUNT}"
    fi
  else
    log_warn "Очистка отключена."
  fi

  # End time / Duration
  END_TIME=$(date +%s)
  DURATION=$((END_TIME - START_TIME))
  log_info "Время: $(date -d @"$START_TIME" +%T) - $(date -d @"$END_TIME" +%T)"
  log_info "⏱ Длительность: $(printf "%02d:%02d:%02d" $((DURATION/3600)) $((DURATION%3600/60)) $((DURATION%60)))"

  UMOUNT_SYS
  log_ok "Архивирование завершено. Файлы: ${BACKUP_PATH}"
}

###############################
### === VERIFY / INFO === ###
###############################

# --- Улучшенный выбор каталога для проверки (-v)
function PROMPT_VERIFY_BACKUP_DIR() {

    log_header "ДОСТУПНЫЕ БЭКАПЫ"

    local dirs=()
    mapfile -t dirs < <(ls -1dt "${BACKUP_ROOT}"/*/ 2>/dev/null)

    if (( ${#dirs[@]} == 0 )); then
        log_error "Бэкапы не найдены."
        return 1
    fi

    echo ""
    echo "Имеющиеся каталоги:"

    for d in "${dirs[@]}"; do
        printf "  %s\n" "$(basename "$d")"
    done

    echo ""
    read -r -p "Введите имя каталога (пример: 10-11-2025_04-42): " USER_DIR

    SELECTED_DIR="${BACKUP_ROOT}/${USER_DIR}"

    local chosen="${BACKUP_ROOT}/${USER_DIR}"

    if [[ ! -d "$chosen" ]]; then
        log_error "Каталог '${USER_DIR}' не найден."
        return 1
    fi

    echo -e "\n\033[1;36mВыбран каталог: ${USER_DIR}\033[0m\n"

    VERIFY_BACKUP_DATE "$chosen"
}

# Verify single date backup (checksums.sha256 inside that directory)
function VERIFY_BACKUP_DATE() {
  local date_dir="$1"
  [[ -z "$date_dir" ]] && return 1
  if [[ ! -f "${date_dir}/checksums.sha256" ]]; then
    log_warn "В директории ${date_dir} нет checksums.sha256"
    return 1
  fi
  log_header "ПРОВЕРКА БЭКАПА: ${date_dir}"
  (cd "${date_dir}" && sha256sum -c checksums.sha256)
}

# Verify all backups
function VERIFY_ALL() {
  log_header "ПРОВЕРКА ВСЕХ БЭКАПОВ"
  for dir in "${BACKUP_ROOT}"/*; do
    [[ -d "$dir" && -f "$dir/checksums.sha256" ]] || continue
    log_info "Проверка: ${dir}"
    (cd "$dir" && sha256sum -c checksums.sha256)
  done
  log_ok "Проверка завершена."
}

# Info about backups
function INFO_BACKUPS() {

    log_header "ИНФОРМАЦИЯ О БЭКАПАХ"

    if [[ ! -d "${BACKUP_ROOT}" ]]; then
        log_error "Каталог ${BACKUP_ROOT} не найден."
        return 1
    fi

    local dirs=()
    mapfile -t dirs < <(ls -1dt "${BACKUP_ROOT}"/*/ 2>/dev/null)

    if (( ${#dirs[@]} == 0 )); then
        log_error "Бэкапы не найдены."
        return 1
    fi

    echo ""
    echo "Имеющиеся каталоги:"

    for d in "${dirs[@]}"; do
        printf "  %s\n" "$(basename "$d")"
    done

    echo ""
    read -r -p "Введите имя каталога (пример: 10-11-2025_04-42): " DATE_IN

    BACKUP_DIR="${BACKUP_ROOT}/${DATE_IN}"

    if [[ ! -d "${BACKUP_DIR}" ]]; then
        log_error "Каталог '${DATE_IN}' не найден."
        return 1
    fi

    echo -e "\n\033[1;36mВыбран каталог: ${DATE_IN}\033[0m\n"

    log_info "Содержимое каталога:"
    printf "%-34s %-19s %-20s\n" "ФАЙЛ" "РАЗМЕР" "ИЗМЕНЁН"
    echo "---------------------------------------------------------------"

    find "${BACKUP_DIR}" -maxdepth 1 -type f -printf "%f\t%10s\t%TY-%Tm-%Td %TH:%TM\n" \
        | awk -F'\t' '{ printf "%-30s %-10.1f MB %-20s\n", $1, $2/1024/1024, $3 }'

    echo "---------------------------------------------------------------"

    local total
    total=$(du -ch "${BACKUP_DIR}"/*tar.* 2>/dev/null | grep total || true)
    log_info "Общий размер архивов: ${total}"

    if [[ -f "${BACKUP_DIR}/checksums.sha256" ]]; then
        log_info "Проверка контрольных сумм:"
        (cd "${BACKUP_DIR}" && sha256sum -c checksums.sha256)
    fi
}

###############################
### === RECOVERY / MAKEPART === ###
###############################
function RECOVERY_TAR() {
    local TARGET_DEV="$1"

    # 1) базовые проверки аргумента
    [[ -z "$TARGET_DEV" ]] && { log_error "Не указан диск! Использование: -r /dev/sdX"; exit 1; }
    [[ ! -b "$TARGET_DEV" ]] && { log_error "$TARGET_DEV не блочное устройство!"; exit 1; }
    if [[ "$TARGET_DEV" == "$SYS_DEV" && "${LIVE_MODE:-false}" == "true" ]]; then
        log_error "Попытка восстановления на системный диск в живой системе!"
        log_info "Запусти из rescue/Live."
        exit 1
    fi

    log_info "Восстановление будет выполняться на ${TARGET_DEV}"
    CHECK_BACKUP_ENV

    # 2) подтверждение от пользователя
    log_header "ВОССТАНОВЛЕНИЕ СИСТЕМЫ НА ${TARGET_DEV}"
    read -r -p "Введите 'YES' для продолжения (всё на ${TARGET_DEV} будет перезаписано): " CONFIRM
    [[ "$CONFIRM" != "YES" ]] && { log_info "Отменено пользователем."; return 1; }

    # 3) вычисляем суффикс для nvme/mmcblk
    local PART_SUFFIX="" t_efi t_boot t_root t_var t_home t_swap
    [[ "$TARGET_DEV" =~ (nvme|mmcblk) ]] && PART_SUFFIX="p"
    t_efi="${TARGET_DEV}${PART_SUFFIX}1"
    t_boot="${TARGET_DEV}${PART_SUFFIX}2"
    t_root="${TARGET_DEV}${PART_SUFFIX}3"
    t_var="${TARGET_DEV}${PART_SUFFIX}4"
    t_swap="${TARGET_DEV}${PART_SUFFIX}5"
    t_home="${TARGET_DEV}${PART_SUFFIX}6"

    # 4) точка монтирования
    mkdir -p "${SYS_DIR}"
    LIVE_MODE=false

    # 5) Монтируем разделы (rootfs первым)
    mount "$t_root" "$SYS_DIR" || { log_error "Не удалось смонтировать rootfs $t_root"; return 1; }
    log_ok "Монтирован $t_root → $SYS_DIR"

    # 6) гарантированный порядок
    declare -A PARTS=(
        [boot]="$SYS_DIR/boot"
        [home]="$SYS_DIR/home"
        [var]="$SYS_DIR/var"
        [efi]="$SYS_DIR/boot/efi"
    )
    PARTS_ORDER=(boot home var efi)

    for p in "${PARTS_ORDER[@]}"; do
        part_dev="t_$p"
        part_dev="${!part_dev}"
        mp="${PARTS[$p]}"
        [[ -b "$part_dev" ]] || continue
        mkdir -p "$mp"
        mount "$part_dev" "$mp" \
            && log_ok "Монтирован $part_dev → $mp" \
            || log_warn "Не удалось смонтировать $part_dev → $mp"
    done

    # 7) bind-монты pseudo-FS для chroot
    for fs in dev proc sys run; do
        mp="$SYS_DIR/$fs"
        mkdir -p "$mp"   # создаём точку монтирования
        mountpoint -q "$SYS_DIR/$fs" || mount --bind "/$fs" "$SYS_DIR/$fs"
    done

    # 8) efivars
    if [[ -d /sys/firmware/efi ]]; then
        mkdir -p "$SYS_DIR/sys/firmware/efi/efivars"
        mountpoint -q "$SYS_DIR/sys/firmware/efi/efivars" || \
                mount -t efivarfs efivarfs "$SYS_DIR/sys/firmware/efi/efivars"
    fi

    # 7) перебираем архивы и распаковываем (rootfs, boot, efi, home, var)
    shopt -s nullglob
    for arc in "${BACKUP_PATH}"/*tar.*; do
        [[ ! -f "$arc" ]] && continue
        name=$(basename "$arc")
        base="${name%%.tar*}"

        case "$base" in
            efi) dest="${SYS_DIR}/boot/efi" ;;
            boot) dest="${SYS_DIR}/boot" ;;
            rootfs) dest="${SYS_DIR}" ;;
            home) dest="${SYS_DIR}/home" ;;
            var) dest="${SYS_DIR}/var" ;;
            *) dest="${SYS_DIR}" ;;
        esac

        mkdir -p "$dest"
        log_info "Восстановление: $arc → $dest"

        case "$arc" in
            *.tar.zst|*.zst|*.tar.zstd)
                if command -v zstd >/dev/null 2>&1; then
                    zstd -d -c "$arc" | tar -xpf - -C "$dest"
                else
                    log_error "zstd не установлен, не могу распаковать $arc"
                fi
                ;;
            *.tar.xz|*.xz)
                xz -d -c "$arc" | tar -xpf - -C "$dest" ;;
            *.tar)
                tar -xpf "$arc" -C "$dest" ;;
            *) log_warn "Неизвестный формат: $arc — пропускаем." ;;
        esac
    done

    # 8) Создаём актуальный /etc/fstab после распаковки
    cat > "$SYS_DIR/etc/fstab" <<EOF
UUID=$(blkid -s UUID -o value "$t_root")   /       xfs defaults 0 1
UUID=$(blkid -s UUID -o value "$t_boot")   /boot   xfs defaults 0 2
UUID=$(blkid -s UUID -o value "$t_efi")    /boot/efi vfat defaults 0 2
UUID=$(blkid -s UUID -o value "$t_home")   /home   xfs defaults 0 2
UUID=$(blkid -s UUID -o value "$t_var")    /var    xfs defaults 0 2
UUID=$(blkid -s UUID -o value "$t_swap")   none    swap sw 0 0
EOF
    log_info "/etc/fstab обновлён после распаковки архивов"

    # 9) сохраняем /etc/resolv.conf, если есть
    if [[ -L "$SYS_DIR/etc/resolv.conf" ]]; then
        mv "$SYS_DIR/etc/resolv.conf" "$SYS_DIR/etc/resolv.conf.link"
        echo "nameserver 1.1.1.1" > "$SYS_DIR/etc/resolv.conf"
    fi

    # 10) установка загрузчика (EFI/BIOS)
    # ... оставляем логику chroot как есть, с efibootmgr для EFI
    log_header "УСТАНОВКА ЗАГРУЗЧИКА НА ${TARGET_DEV}"
    ROOT_UUID=$(blkid -s UUID -o value "$t_root")

    if [[ -d "${SYS_DIR}/boot/efi/EFI" ]]; then
        log_info "Обнаружен EFI: установка GRUB для UEFI…"

        if chroot "$SYS_DIR" bash -c "echo 'root=UUID=$ROOT_UUID ro rhgb quiet' > /etc/kernel/cmdline"; then
            log_ok "Параметры ядра сформированы успешно"
        else
            log_error "Ошибка при формировании параметров ядра"
        fi

        if chroot "$SYS_DIR" rm -f /boot/efi/EFI/fedora/grub.cfg /boot/grub2/grub.cfg; then
            log_ok "Удаление конфигурации загрузчика успешно"
        else
            log_error "Ошибка при удалении конфигурации загрузчика"
        fi

        if chroot "$SYS_DIR" dnf -y reinstall shim-* grub2-efi-* grub2-common; then
            log_ok "Переустановка загрузчика успешно"
        else
        log_error "Ошибка при переустановке загрузчика"
        fi

        if chroot "$SYS_DIR" grub2-mkconfig -o /boot/grub2/grub.cfg; then
            log_ok "Обновлена конфигурация загрузчика успешно"
        else
            log_error "Ошибка при обновлении конфигурации загрузчика"
        fi

        if chroot "$SYS_DIR" efibootmgr --create --disk "$TARGET_DEV" -p 1 -l '\EFI\fedora\shimx64.efi' -L 'Fedora-Rest'; then
            log_ok "Добавлена загрузочная запись UEFI успешно"
        else
            log_error "Ошибка при добавлении загрузочной записи UEFI"
        fi

        if chroot "$SYS_DIR" /sbin/restorecon -RF /; then
            log_ok "Восстановление SELinux контекстов успешно"
        else
        log_error "Ошибка при восстановлении SELinux контекстов"
        fi

    else

        if chroot "$SYS_DIR" bash -c "echo 'root=UUID=$ROOT_UUID ro rhgb quiet' > /etc/kernel/cmdline"; then
            log_ok "Параметры ядра сформированы успешно"
        else
            log_error "Ошибка при формировании параметров ядра"
        fi

        if chroot "$SYS_DIR" rm -f /boot/efi/EFI/fedora/grub.cfg /boot/grub2/grub.cfg; then
            log_ok "Удаление конфигурации загрузчика успешно"
        else
            log_error "Ошибка при удалении конфигурации загрузчика"
        fi

        if chroot "$SYS_DIR" grub2-install "$TARGET_DEV"; then
            log_ok "Установка загрузчика успешно"
        else
            log_error "Ошибка при установке загрузчика"
        fi

        if chroot "$SYS_DIR" grub2-mkconfig -o /boot/grub2/grub.cfg; then
            log_ok "Обновлена конфигурация загрузчика успешно"
        else
        log_error "Ошибка при обновлении конфигурации загрузчика"
        fi

        if chroot "$SYS_DIR" /sbin/restorecon -RF /; then
            log_ok "Восстановление SELinux контекстов успешно"
        else
            log_error "Ошибка при восстановлении SELinux контекстов"
        fi

    fi

    # 11) восстанавливаем оригинальный resolv.conf
    if [[ -f "$SYS_DIR/etc/resolv.conf.link" ]]; then
        rm -f "$SYS_DIR/etc/resolv.conf"
        mv "$SYS_DIR/etc/resolv.conf.link" "$SYS_DIR/etc/resolv.conf"
    fi

    # 12) корректное размонтирование в обратном порядке
    log_info "Размонтирование целевого дерева ${SYS_DIR}…"

    # efivars отдельно
    mountpoint -q "$SYS_DIR/sys/firmware/efi/efivars" && umount "$SYS_DIR/sys/firmware/efi/efivars"

    # размонтирование pseudo-FS
    for fs in run sys proc dev; do
        mountpoint -q "$SYS_DIR/$fs" && umount "$SYS_DIR/$fs"
    done

    # обычные разделы — в обратном порядке
    for (( idx=${#PARTS_ORDER[@]}-1 ; idx>=0 ; idx-- )); do
        p="${PARTS_ORDER[idx]}"
        mp="${PARTS[$p]}"
        mountpoint -q "$mp" && umount "$mp"
    done

    # rootfs — последним
    mountpoint -q "$SYS_DIR" && umount "$SYS_DIR"

    # принудительный сброс на диск
    sync && sync
    log_ok "Восстановление на ${TARGET_DEV} завершено."
}



function MAKE_PART() {
    local TARGET_DEV="$1"

    if [[ -z "$TARGET_DEV" ]]; then
        log_error "Не указан диск для разметки!"
        exit 1
    fi

    # Проверяем, что устройство существует
    if [[ ! -b "$TARGET_DEV" ]]; then
        log_error "$TARGET_DEV не является блочным устройством!"
        exit 1
    fi

    # Определяем реальный системный диск (диск, где смонтирован /)
    local REAL_SYSTEM_DEV PARTNAME
    PARTNAME=$(findmnt -n -o SOURCE /)
    REAL_SYSTEM_DEV="/dev/$(lsblk -no PKNAME "$PARTNAME")"

    # Запрещаем разметку системного диска в живой системе
    if mountpoint -q / && [[ "$TARGET_DEV" == "$REAL_SYSTEM_DEV" ]]; then
        log_error "Попытка разметки системного диска ($TARGET_DEV) в живой системе!"
        log_info "Запустите скрипт в режиме rescue/offline."
        exit 1
    fi

    log_info "Разметка и подготовка ${TARGET_DEV}"
    CHECK_BACKUP_ENV

    local DST_DEV="$TARGET_DEV"

    log_header "СОЗДАНИЕ РАЗДЕЛОВ НА ${DST_DEV}"
    log_warn "ВНИМАНИЕ: Все данные на устройстве будут уничтожены!"

    log_info "Текущая структура разделов:"
    lsblk "${DST_DEV}"

    read -r -p "Введите 'YES' для продолжения: " CONFIRM
    [[ "${CONFIRM}" != "YES" ]] && { log_info "Отменено пользователем."; return 1; }

    log_info "Создание GPT разметки на ${DST_DEV}"
    parted -a optimal -s "${DST_DEV}" mklabel gpt

    log_info "Создание разделов${ELLIPSIS}"
    parted -a optimal -s "${DST_DEV}" \
        mkpart primary fat32 1MiB 101MiB \
        set 1 esp on \
        name 1 "EFI" \
        mkpart primary xfs 101MiB 2149MiB \
        name 2 "Boot" \
        mkpart primary xfs 2149MiB 102149MiB \
        name 3 "RootFS" \
        mkpart primary xfs 102149MiB 117349MiB \
        name 4 "Var" \
        mkpart primary linux-swap 117349MiB 132549MiB \
        name 5 "Swap" \
        mkpart primary xfs 132549MiB 100% \
        name 6 "HomeDirs"

    local PART_SUFFIX=""
    [[ "${DST_DEV}" =~ (nvme|mmcblk) ]] && PART_SUFFIX="p"

    log_info "Форматирование разделов${ELLIPSIS}"
    mkfs.fat -F32 -n EFI "${DST_DEV}${PART_SUFFIX}1" && log_ok "EFI раздел отформатирован"
    mkfs.xfs -f -L BOOT  "${DST_DEV}${PART_SUFFIX}2" && log_ok "Boot раздел отформатирован"
    mkfs.xfs -f -L ROOTFS "${DST_DEV}${PART_SUFFIX}3" && log_ok "RootFS раздел отформатирован"
    mkfs.xfs -f -L VAR  "${DST_DEV}${PART_SUFFIX}4" && log_ok "Var раздел отформатирован"
    mkswap -L SWAP "${DST_DEV}${PART_SUFFIX}5" && log_ok "Swap раздел создан"
    mkfs.xfs -f -L HOMES "${DST_DEV}${PART_SUFFIX}6" && log_ok "Home раздел отформатирован"

    log_ok "Разметка и форматирование диска ${DST_DEV} завершены."

    log_info "Итоговая структура разделов:"
    lsblk -f "${DST_DEV}"
}

###############################
### === HELP / MAIN === ###
###############################
function HELP() {
    cat <<HELP_EOF
${ME} — резервное копирование системы TAR-архивами

Использование:
  -b    создать резервные архивы (backup)
  -r [УСТРОЙСТВО]  восстановить систему (recovery)
  -c [УСТРОЙСТВО]  создать структуру разделов на диске
  -i    показать информацию о бэкапах и предложить проверку
  -v    проверить контрольные суммы для указанной даты (ручная проверка)
  -V    если вместе с -b -> проверить только что созданный бэкап;
        если один -> проверить ВСЕ бэкапы (sha256sum -c)
  --no-icons   Отключить Unicode-иконки в логах (ASCII режим)
  -h    справка

Логирование:
  Уровень детализации: ERROR(1) < WARN(2) < INFO(3) < DEBUG(4)
  По умолчанию: INFO(3). Для отладки: LOG_LEVEL=4 $ME -b

Примеры:
  $ME -b                          # Создать бэкап
  $ME -r /dev/sdb                 # Восстановить систему на /dev/sdb
  $ME -c /dev/sdb                 # Создать разделы на /dev/sdb
  $ME -i                          # Показать информацию о бэкапах
  LOG_LEVEL=2 $ME -b              # Только предупреждения и ошибки

Версия: ${VERSION} (с профессиональным логированием)
HELP_EOF
}

# parse options — allow combined flags; track actions
DO_BACKUP=false
DO_RECOVER=false
DO_MAKEPART=false
DO_INFO=false
DO_VERIFY_DATE=false
DO_VERIFY_ALL=false
VERIFY_AFTER=false
MAKEPART_ARG=""
RECOVER_ARG=""

# -----------------------------
# Обработка длинных опций
# -----------------------------
# Собираем новый список аргументов без --no-icons
NEW_ARGS=()
for arg in "$@"; do
  case "$arg" in
    --no-icons)
      NO_ICONS=true
      ;;
    *)
      NEW_ARGS+=("$arg")
      ;;
  esac
done

# Подменяем аргументы для дальнейшего парсинга getopts
set -- "${NEW_ARGS[@]}"

while getopts "br:c:ivVh" opt; do
  case $opt in
      b) MODE="ARCHIVE"
         DO_BACKUP=true ;;
      r) MODE="RECOVER"
         DO_RECOVER=true
         RECOVER_ARG="$OPTARG" ;;
      c) MODE="MAKEPART"
         DO_MAKEPART=true
         MAKEPART_ARG="$OPTARG";;
      i) MODE="INFO"
         DO_INFO=true ;;
      v) MODE="VERIFY"
         DO_VERIFY_DATE=true ;;
      V) MODE="VERIFY"
         DO_VERIFY_ALL=true ;;
      h) HELP; exit 0 ;;
      *) STATUS="FAILED"
         HELP; exit 1 ;;
  esac
done

# Применяем --no-icons, если нужно
if [[ "$NO_ICONS" == true ]]; then
  OK_ICON=""
  WARN_ICON=""
  ERR_ICON=""
  INFO_ICON=""
  DEBUG_ICON=""
  ARROW=""
  ELLIPSIS=""
fi

#if (( DO_BACKUP + DO_RECOVER + DO_MAKEPART + DO_INFO + DO_VERIFY_DATE + DO_VERIFY_ALL > 1 )); then
#    log_error "Указано несколько режимов одновременно"
#    STATUS="FAILED"
#    exit 1
#fi

if [[ -z "$MODE" ]]; then
    HELP
    STATUS="FAILED"
    exit 1
fi

log_session_start
detect_mode_and_print_info

# If both -b and -V passed, set VERIFY_AFTER to check created backup
if [[ "$DO_BACKUP" == true && "$DO_VERIFY_ALL" == true ]]; then
    VERIFY_AFTER=true
fi

# Запуск действий в разумной последовательности
if [[ "$DO_BACKUP" == true ]]; then
    CREATE_TAR
    if [[ "$VERIFY_AFTER" == true ]]; then
        log_header "АВТОМАТИЧЕСКАЯ ПРОВЕРКА СОЗДАННОГО БЭКАПА"
        VERIFY_BACKUP_DATE "${BACKUP_PATH}" || log_warn "Проверка обнаружила ошибки."
    fi
fi

if [[ "$DO_VERIFY_ALL" == true && "$DO_BACKUP" != true ]]; then
    VERIFY_ALL
fi

if [[ "$DO_VERIFY_DATE" == true ]]; then
    PROMPT_VERIFY_BACKUP_DIR
fi

if [[ "$DO_INFO" == true ]]; then
    INFO_BACKUPS
fi

if [[ "$DO_MAKEPART" == true ]]; then
    MAKE_PART "${MAKEPART_ARG:-}"
fi

if [[ "$DO_RECOVER" == true ]]; then
    # 1) Выбор каталога бэкапа
    PROMPT_VERIFY_BACKUP_DIR
    BACKUP_PATH="${SELECTED_DIR}"

    # 2) Проверка, что каталог выбран и существует
    if [[ -z "$BACKUP_PATH" || ! -d "$BACKUP_PATH" ]]; then
        log_error "Не выбран каталог для восстановления или он не существует."
        exit 1
    fi

    # 3) Вызов функции восстановления архивов
    RECOVERY_TAR "${RECOVER_ARG:-}"
fi

log_ok "Скрипт завершил работу"
log_separator
exit 0

[ROOT]

Checklist

1. 2–3 восстановления подряд
   
   • разные диски (virtio / sata / nvme, если есть)
   • UEFI без Secure Boot (как сейчас)
   • желательно один раз включить Secure Boot чисто для уверенности
2. Каждый раз проверять одинаковый чек-лист:
   
   • есть ли /boot/efi/EFI/fedora/grub.cfg
   • куда он указывает (set prefix=)
   • совпадает ли UUID root:
     
     • /etc/fstab
     • /etc/kernel/cmdline
     • /boot/grub2/grub.cfg
   • факт старта без ручного вмешательства

[ROOT]

Код: выделить все