Обработка ошибок и коды возврата

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ

Разработчику Архитектору

Обработка ошибок и коды возврата

Интерактивное демо — в Bash нет исключений, ошибка — код возврата ($?); демо показывает стек и сценарий обработки сбоя. Подробнее: ошибки и исключения.

Загрузка демо исключений…

Что такое ошибка в скрипте

Ошибка — это ситуация, при которой выполнение команды или скрипта не достигает ожидаемого результата. В операционных системах Unix-подобного семейства, к которым относится Linux и macOS, каждая команда завершает свою работу с определенным статусом. Этот статус сообщает системе и вызывающему процессу, завершилась ли задача успешно или возникла проблема.

Ошибки могут возникать по множеству причин: отсутствие необходимых файлов, недостаточные права доступа, неверный синтаксис команды, переполнение памяти, сетевые сбои или логические ошибки в самом коде скрипта. Система не останавливает выполнение скрипта автоматически при первой же ошибке, если для этого явно не заданы соответствующие параметры. Это позволяет разработчику самому решать, как реагировать на неудачи: пропустить их, записать в лог, прервать выполнение или попытаться исправить ситуацию.

Понимание природы ошибок критически важно для создания надежных автоматизированных решений. Скрипт, который игнорирует все ошибки, может продолжить работу с некорректными данными, что приведет к потере информации или повреждению систем. Напротив, скрипт, который слишком строго реагирует на малейшие отклонения, может стать непрактичным и часто останавливаться в реальных условиях эксплуатации.

Код завершения (exit status)

Код завершения (exit status) — это целое число, которое возвращает команда или скрипт при завершении своей работы. Этот код передается операционной системе и доступен следующей выполняемой команде. Значение кода завершения интерпретируется системой как индикатор успеха или типа ошибки.

Стандартная конвенция в Unix-системах гласит, что значение 0 означает успешное выполнение задачи. Любое другое значение, находящееся в диапазоне от 1 до 255, указывает на наличие ошибки. Различные программы используют разные значения для обозначения конкретных типов проблем, что позволяет пользователям и скриптам различать причины сбоев. Например, программа может вернуть код 1 для общего сбоя, код 2 для неправильного использования аргументов командной строки, а код 127 для отсутствия найденной команды.

Важно отметить, что диапазон значений ограничен одним байтом. Максимальное значение составляет 255. Если команда пытается вернуть код больше этого числа, система использует остаток от деления на 256. Например, попытка вернуть 300 приведет к тому, что фактический код завершения будет равен 44 (так как 300 - 256 = 44).

Каждая команда в Bash имеет свой собственный набор возможных кодов завершения. Некоторые утилиты, такие как grep, имеют специфическую логику: они возвращают 0, если найдено совпадение, 1, если совпадений нет, и 2 при ошибке выполнения. Понимание этих нюансов необходимо для правильной обработки результатов работы различных инструментов.

Система сохраняет код последней выполненной команды в специальной переменной окружения. Эта переменная доступна сразу после завершения любой операции и позволяет скрипту принимать решения на основе результата предыдущего действия.

Переменная $? с кодом последней команды

Переменная $? — это встроенная специальная переменная оболочки Bash, которая содержит код завершения (exit status) команды, выполненной непосредственно перед обращением к этой переменной. Значение этой переменной обновляется каждый раз после завершения любой исполняемой команды, включая встроенные команды оболочки, внешние утилиты и пользовательские скрипты.

Использование $? является основным способом проверки успешности выполнения операций в скриптах. После запуска команды можно мгновенно проверить её результат, сравнив значение $? с нулем. Если значение равно 0, операция прошла успешно. Любое другое значение сигнализирует о проблеме, и конкретный номер кода может указать на тип возникшей ошибки.

Пример использования:

ls /nonexistent_directory
echo "Код завершения: $?"

В данном случае команда ls попытается вывести содержимое несуществующей директории. Команда завершится с ошибкой, и переменная $? получит значение, отличное от нуля (обычно 2 или 1, в зависимости от реализации). Следующая команда echo выведет этот код на экран.

Важно помнить, что обращение к переменной $? само по себе является выполнением команды. Если после проверки кода завершения выполнить другую команду (например, echo или test), то значение $? изменится на результат этой новой команды. Поэтому проверку кода завершения следует проводить немедленно после целевой операции, без промежуточных действий.

Для сохранения значения кода завершения в отдельную переменную перед выполнением других команд используют следующее решение:

my_command
status=$?
if [ $status -ne 0 ]; then
    echo "Произошла ошибка с кодом $status"
fi

Такой подход гарантирует, что значение кода завершения не будет потеряно при выполнении последующих инструкций скрипта.

Флаги set: -e, -u, -o и прочие

Команда set используется для установки параметров поведения оболочки Bash. Эти параметры влияют на то, как оболочка обрабатывает ошибки, пустые переменные и другие условия во время выполнения скрипта. Использование флагов set является лучшей практикой для написания надежных и предсказуемых скриптов.

Флаг `-e` (errexit)

Флаг -e заставляет оболочку немедленно завершать выполнение скрипта, если любая команда возвращает ненулевой код завершения. Это ключевой механизм для обеспечения того, чтобы скрипт не продолжал работу в случае возникновения ошибок. Без этого флага скрипт может продолжить выполнение после неудачной команды, используя некорректные данные или создавая нежелательные последствия.

При использовании флага -e скрипт останавливается в момент, когда первая ошибка встречается. Однако существуют исключения из этого правила. Ошибки в условных операторах (if, while, for) не приводят к немедленному завершению, так как ожидается, что эти конструкции будут обрабатывать возможные неудачи. Также ошибки в цепочках команд, соединенных операторами && или ||, игнорируются, так как логика этих операторов предполагает обработку разных исходов.

Пример использования:

#!/bin/bash
set -e

# Скрипт остановится здесь, если файл не существует
cat nonexistent_file.txt

# Эта строка никогда не выполнится
echo "Это сообщение будет выведено только если cat прошел успешно"

Флаг `-u` (nounset)

Флаг -u приводит к немедленному завершению скрипта при попытке обратиться к неопределенной переменной. Это помогает избежать ошибок, связанных с использованием переменных, которые были забыты инициализировать или опечаток в их именах. Без этого флага обращение к несуществующей переменной просто заменится на пустую строку, что может привести к логическим ошибкам, которые трудно отследить.

Пример использования:

#!/bin/bash
set -u

name=""
# Попытка использовать переменную user_name вызовет ошибку, так как она не определена
echo "Привет, $user_name!"

В этом примере скрипт завершится с ошибкой, указывая на использование неопределенной переменной.

Флаг `-o pipefail`

Флаг -o pipefail изменяет поведение обработки кодов завершения в конвейерах (pipe). По умолчанию, если команда в конце конвейера завершается успешно, весь конвейер считается успешным, даже если одна из предыдущих команд внутри него потерпела неудачу. При установке флага -o pipefail конвейер возвращает код завершения последней команды, которая завершилась с ошибкой. Если все команды выполнены успешно, возвращается 0.

Это критически важно для надежности скриптов, использующих конвейеры. Без этого флага ошибка в середине конвейера может остаться незамеченной.

Пример использования:

#!/bin/bash
set -o pipefail

# Если grep не найдет ничего, он вернет 1, но команда wc -l всё равно вернет 0
# Без pipefail скрипт продолжит работу, считая всё успешным
grep "error" file.txt | wc -l

Флаг `-n` (noexec)

Флаг -n предотвращает выполнение команд. Оболочка читает скрипт, проверяет синтаксис, но не выполняет никаких действий. Это полезно для предварительной проверки корректности скрипта без его фактического запуска.

Флаг `-v` (verbose)

Флаг -v включает режим подробного вывода. Оболочка выводит каждую команду перед её выполнением, что очень удобно для отладки сложных скриптов.

Флаг `-x` (xtrace)

Флаг -x включает трассировку выполнения. Оболочка выводит каждую команду с расширенными параметрами перед её выполнением. Это позволяет увидеть точное состояние переменных и аргументов в момент выполнения. Часто используется совместно с флагом -v.

Комбинированное использование

Рекомендуется использовать несколько флагов одновременно для максимальной безопасности скрипта. Стандартный набор для production-скриптов выглядит следующим образом:

#!/bin/bash
set -euo pipefail

Эта комбинация обеспечивает:

Немедленное завершение при любой ошибке (-e);
Защиту от использования неопределенных переменных (-u);
Корректную обработку конвейеров (-o pipefail).

Основные методы обработки ошибок

Обработка ошибок в Bash базируется на нескольких основных подходах. Выбор метода зависит от контекста задачи и требований к надежности скрипта.

Проверка кода завершения

Самый распространенный метод — явная проверка кода завершения каждой важной команды. Для этого используют конструкцию if, проверяющую значение переменной $? или результат выполнения команды напрямую.

Пример проверки:

cp source.txt destination.txt
if [ $? -eq 0 ]; then
    echo "Файл скопирован успешно"
else
    echo "Ошибка копирования файла"
    exit 1
fi

Более компактный вариант использует прямой результат команды в условии:

if cp source.txt destination.txt; then
    echo "Успех"
else
    echo "Неудача"
fi

В этом случае условие if принимает значение true, если команда вернула 0, и false в противном случае.

Логические операторы

Bash предоставляет логические операторы && (и) и || (или), которые позволяют выполнять команды последовательно в зависимости от результата предыдущей.

Оператор && выполняет следующую команду только если предыдущая завершилась успешно (вернула 0). Оператор || выполняет следующую команду только если предыдущая завершилась с ошибкой (вернула ненулевое значение).

Пример использования &&:

mkdir my_folder && cd my_folder

Команда cd выполнится только если создание папки прошло успешно.

Пример использования ||:

make clean || echo "Очистка не удалась, продолжаем..."

Сообщение об ошибке выведется только если команда make clean завершится неудачно.

Можно комбинировать оба оператора для создания сложных цепочек обработки:

command_a && command_b || { echo "Ошибка в A или B"; exit 1; }

Условный оператор if/then/else/fi

Конструкция if/then/else/fi является наиболее гибким инструментом для обработки различных сценариев. Она позволяет проверять не только код завершения, но и состояния переменных, наличие файлов и другие условия.

Структура:

if [ условие ]; then
    # Блок кода при истинном условии
elif [ другое_условие ]; then
    # Блок кода при истинности другого условия
else
    # Блок кода при ложности всех условий
fi

Пример обработки ошибок ввода:

read -p "Введите имя файла: " filename

if [ -f "$filename" ]; then
    echo "Файл существует, приступаем к обработке"
    process_file "$filename"
elif [ -d "$filename" ]; then
    echo "Это директория, обработка невозможна"
    exit 1
else
    echo "Файл не найден, создаем новый"
    touch "$filename"
fi

Возврат значений из функций: return N

Внутри функций Bash можно использовать команду return для передачи кода завершения обратно вызывающему коду. Значение, переданное в return, становится кодом завершения функции и доступно через переменную $? после вызова функции.

Это позволяет создавать функции, которые сами определяют свои коды ошибок, вместо того чтобы полагаться на последние выполненные команды внутри них.

Пример функции с возвратом кодов:

check_disk_space() {
    local usage=$(df -h / | tail -1 | awk '{print $5}' | tr -d '%')
    
    if [ "$usage" -gt 90 ]; then
        echo "Критический уровень заполнения диска: ${usage}%"
        return 2
    elif [ "$usage" -gt 80 ]; then
        echo "Предупреждение: заполнено ${usage}%"
        return 1
    else
        echo "Диск в норме: ${usage}%"
        return 0
    fi
}

check_disk_space
status=$?
if [ $status -eq 2 ]; then
    echo "Требуется срочное вмешательство!"
elif [ $status -eq 1 ]; then
    echo "Нужно запланировать очистку"
fi

Прерывание скрипта: exit N

Команда exit завершает выполнение всего скрипта и передает указанный код завершения родительскому процессу. Это основной способ сообщить внешней системе о том, что скрипт закончил работу с ошибкой.

Использование exit обычно происходит в блоках обработки ошибок или в начале скрипта при проверке обязательных условий.

Пример:

if [ ! -f "/etc/passwd" ]; then
    echo "Критическая ошибка: файл /etc/passwd отсутствует"
    exit 127
fi

# Дальнейшее выполнение скрипта

Часто используются стандартные коды ошибок:

0 — успех;
1 — общая ошибка;
2 — неправильное использование командной строки;
126 — команда найдена, но не может быть выполнена;
127 — команда не найдена;
128 + сигнал — если скрипт был прерван сигналом (например, 130 для SIGINT).

Ловушки trap

Trap — это механизм в Bash, позволяющий перехватывать сигналы и выполнять определенные команды при их получении. Сигналы — это сообщения, которые операционная система отправляет процессу для уведомления о событиях: прерывании пользователем, ошибке выполнения, завершении работы и т.д.

Команда trap связывает сигнал с командой или функцией, которая должна быть выполнена при получении этого сигнала. Это мощный инструмент для обеспечения чистоты выполнения скрипта: освобождения временных файлов, закрытия соединений, восстановления состояния системы.

Синтаксис trap

trap 'команды' сигнал1 сигнал2 ...

Где сигнал может быть указан по имени (например, INT, TERM) или по номеру (например, 2, 15).

Обработка сигнала прерывания (SIGINT)

Сигнал INT (номер 2) генерируется при нажатии клавиш Ctrl+C. Это самый частый случай использования trap.

Пример защиты от незавершенной работы:

#!/bin/bash

cleanup() {
    echo "Завершение работы..."
    rm -f /tmp/temp_file_$$.txt
    echo "Временные файлы удалены"
    exit 1
}

trap cleanup INT TERM

echo "Скрипт запущен. Нажмите Ctrl+C для остановки."
sleep 100

При нажатии Ctrl+C сработает функция cleanup, которая удалит временные файлы и завершит скрипт.

Обработка сигналов выхода (EXIT)

Специальный сигнал EXIT срабатывает при любом выходе из скрипта, независимо от причины. Это удобно для финальной очистки ресурсов.

#!/bin/bash

cleanup() {
    echo "Выполняется финальная очистка..."
    # Закрытие соединений, удаление логов и т.д.
}

trap cleanup EXIT

# Основная работа скрипта
process_data

Перехват сигналов ошибок

Можно настроить обработку сигналов, возникающих при ошибках выполнения, таких как ERR. Однако поддержка сигнала ERR зависит от версии Bash и может быть включена только при использовании флага -E (что эквивалентно set -e).

trap 'echo "Произошла ошибка! Выполняем аварийную остановку."' ERR

Отключение обработчиков

Чтобы отключить обработку определенного сигнала, используют пустую команду:

trap '' INT

Это предотвратит выполнение функции очистки при нажатии Ctrl+C.

Сохранение оригинальных обработчиков

Если нужно временно изменить поведение обработки сигнала, а затем восстановить исходное, используют сохранение текущих ловушек:

original_trap=$(trap -p INT)
trap new_handler INT
# ... работа ...
eval "$original_trap"

Отладка и трассировка

Отладка скриптов Bash требует специальных инструментов, так как стандартный вывод может быть недостаточно информативным. Оболочка предоставляет несколько механизмов для отслеживания выполнения кода.

Флаг -x (трассировка)

Флаг -x включает режим трассировки. При его активации оболочка выводит каждую команду перед её выполнением, раскрывая все подстановки переменных и расширения. Каждая строка вывода начинается со знака +.

Пример использования:

#!/bin/bash
set -x

name="World"
echo "Hello, $name!"

Результат:

+ name=World
+ echo 'Hello, World!'
Hello, World!

Этот режим особенно полезен для понимания того, как именно оболочка интерпретирует сложные выражения и переменные.

Флаг -v (подробный вывод)

Флаг -v включает режим подробного вывода. Оболочка показывает каждую строку скрипта перед её обработкой, но без раскрытия подстановок. Это помогает понять порядок чтения скрипта.

#!/bin/bash
set -v

echo "Тест"

Результат:

+ echo "Тест"
Тест

Комбинация -x и -v

Использование обоих флагов вместе дает максимальную информацию для отладки:

set -xv

Вывод отладочной информации в лог

Вместо вывода в консоль можно перенаправлять трассировку в файл:

exec > debug.log 2>&1
set -x
# ... работа скрипта ...

Это позволяет сохранять полную историю выполнения для последующего анализа.

Использование printf для отладки

Вручную добавленные команды printf или echo с метками помогают локализовать проблемы:

debug() {
    echo "[DEBUG] $1" >&2
}

process_data() {
    debug "Начало обработки"
    # ... код ...
    debug "Конец обработки"
}

Инструмент shellcheck

Shellcheck — это статический анализатор для скриптов Bash. Он проверяет код на наличие потенциальных ошибок, уязвимостей и антипаттернов. Shellcheck не выполняет скрипт, а анализирует его текст, указывая на проблемные места.

Пример использования:

shellcheck script.sh

Инструмент выдаст предупреждения вида:

script.sh: line 10: unused variable 'TEMP'
script.sh: line 15: quotes needed around variable expansion

Логи и аудит

Для серьезной отладки рекомендуется включать детальное логирование в сам скрипт. Использование logger для записи сообщений в системный журнал позволяет централизованно управлять диагностической информацией.

logger -t "myscript" "Запуск процесса обработки"
logger -t "myscript" "Ошибка: файл не найден"

Практические примеры обработки ошибок

Пример 1: Проверка наличия зависимостей

#!/bin/bash
set -euo pipefail

check_dependency() {
    local cmd="$1"
    if ! command -v "$cmd" &> /dev/null; then
        echo "Ошибка: необходим пакет '$cmd'" >&2
        exit 127
    fi
}

check_dependency "git"
check_dependency "python3"
check_dependency "docker"

echo "Все зависимости установлены"

Пример 2: Безопасное удаление файлов

#!/bin/bash
set -euo pipefail

cleanup_files() {
    local files=(file1.txt file2.txt file3.txt)
    
    for file in "${files[@]}"; do
        if [ -f "$file" ]; then
            echo "Удаление $file..."
            rm -f "$file" || {
                echo "Не удалось удалить $file" >&2
                continue
            }
        fi
    done
}

cleanup_files
echo "Очистка завершена"

Пример 3: Обработка аргументов командной строки

#!/bin/bash
set -euo pipefail

if [ $# -eq 0 ]; then
    echo "Использование: $0 <файл>" >&2
    exit 2
fi

input_file="$1"

if [ ! -f "$input_file" ]; then
    echo "Ошибка: файл '$input_file' не найден" >&2
    exit 1
fi

echo "Обработка файла: $input_file"
# Дальнейшая логика

См. также

Другие статьи этого же раздела в боковом меню (как на странице «О разделе»).