Тестирование условий в Linux

Введение

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

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

Основы команды test

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

Начнем с основ. Сначала перейдите в каталог проекта:

cd ~/project

Команда test может быть записана двумя способами:

1. Использовать слово test, за которым следует условие.
2. Использовать квадратные скобки [ ] вокруг условия.

Попробуем оба метода, чтобы проверить, существует ли каталог:

## Метод 1: Использование слова 'test'
test -d ~/project && echo "The project directory exists."

## Метод 2: Использование квадратных скобок
[ -d ~/project ] && echo "The project directory exists."

Вы должны увидеть следующий вывод для обеих команд:

The project directory exists.

Опция -d проверяет, существует ли каталог. Оператор && используется для выполнения команды echo только в том случае, если условие проверки истинно.

Некоторые распространенные опции проверки файлов включают:

• -d файл: Истинно, если файл существует и является каталогом.
• -e файл: Истинно, если файл существует.
• -f файл: Истинно, если файл существует и является обычным файлом.
• -r файл: Истинно, если файл существует и доступен для чтения.
• -w файл: Истинно, если файл существует и доступен для записи.
• -x файл: Истинно, если файл существует и является исполняемым.
• -s файл: Истинно, если файл существует и его размер больше нуля.

Создадим тестовый файл и проверим его свойства:

## Создать тестовый файл
echo "Hello, Linux condition testing!" > test_file.txt

## Проверить, существует ли файл
test -e test_file.txt && echo "The file exists."

## Проверить, доступен ли файл для чтения
[ -r test_file.txt ] && echo "The file is readable."

## Проверить, пуст ли файл
[ -s test_file.txt ] && echo "The file is not empty."

Эти команды должны выдать следующий вывод:

The file exists.
The file is readable.
The file is not empty.

Теперь создадим простой сценарий оболочки, который использует команду test для проверки существования файла и, если он не существует, создания его:

## Создать файл сценария
cat > check_file.sh << 'EOF'
#!/bin/bash

FILENAME="status.txt"

if [ ! -e "$FILENAME" ]; then
  echo "File $FILENAME does not exist. Creating it now."
  echo "This is a status file." > "$FILENAME"
else
  echo "File $FILENAME already exists."
fi

## Отобразить содержимое файла
echo "Content of $FILENAME:"
cat "$FILENAME"
EOF

## Сделать сценарий исполняемым
chmod +x check_file.sh

## Запустить сценарий
./check_file.sh

При запуске сценария вы должны увидеть вывод, похожий на следующий:

File status.txt does not exist. Creating it now.
Content of status.txt:
This is a status file.

Если вы запустите сценарий еще раз, вы увидите:

File status.txt already exists.
Content of status.txt:
This is a status file.

Это демонстрирует, как использовать команду test для проверки существования файла и выполнения различных действий на основе результата.

Тестирование строковых условий

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

Общие операторы сравнения строк включают:

• ==: Равно
• !=: Не равно
• -z: Истинно, если строка пуста
• -n: Истинно, если строка не пуста

Начнем с проверки различных строковых условий:

## Проверить, равны ли две строки
str1="linux"
str2="linux"
[ "$str1" == "$str2" ] && echo "The strings are equal."

## Проверить, различны ли две строки
str3="ubuntu"
[ "$str1" != "$str3" ] && echo "The strings are different."

## Проверить, пуста ли строка
empty_str=""
[ -z "$empty_str" ] && echo "The string is empty."

## Проверить, не пуста ли строка
[ -n "$str1" ] && echo "The string is not empty."

Вывод должен быть следующим:

The strings are equal.
The strings are different.
The string is empty.
The string is not empty.

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

## Создать скрипт проверки пароля
cat > password_check.sh << 'EOF'
#!/bin/bash

echo "Enter a password:"
read -s password

## Проверить, пуст ли пароль
if [ -z "$password" ]; then
  echo "Error: Password cannot be empty."
  exit 1
fi

## Проверить длину пароля
if [ ${#password} -lt 8 ]; then
  echo "Error: Password must be at least 8 characters long."
  exit 1
fi

## Проверить, содержит ли пароль слово "password"
if [[ "$password" == *password* ]]; then
  echo "Error: Password cannot contain the word 'password'."
  exit 1
fi

echo "Password is valid!"
EOF

## Сделать скрипт исполняемым
chmod +x password_check.sh

## Запустить скрипт
echo "You can test the script by running: ./password_check.sh"

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

## Тестирование с коротким паролем
echo "short" | ./password_check.sh

## Тестирование с паролем, содержащим "password"
echo "mypassword123" | ./password_check.sh

## Тестирование с допустимым паролем
echo "SecurePass123" | ./password_check.sh

Первые два теста должны завершиться неудачей, а третий - успешно.

Создадим еще один скрипт, который обрабатывает статус системы на основе текстового ввода:

## Создать скрипт статуса системы
cat > system_status.sh << 'EOF'
#!/bin/bash

echo "Enter system status (normal, warning, critical):"
read status

if [ -z "$status" ]; then
  echo "No status provided. Assuming normal operation."
  status="normal"
fi

case "$status" in
  "normal")
    echo "System is operating normally. No action required."
    ;;
  "warning")
    echo "Warning: System requires attention. Check log files."
    ;;
  "critical")
    echo "CRITICAL: Immediate action required! System stability at risk."
    ;;
  *)
    echo "Unknown status: $status. Please use normal, warning, or critical."
    ;;
esac
EOF

## Сделать скрипт исполняемым
chmod +x system_status.sh

## Запустить скрипт
echo "You can test the script by running: ./system_status.sh"

Попробуйте запустить скрипт с разными статусами:

## Тестирование со статусом "normal"
echo "normal" | ./system_status.sh

## Тестирование со статусом "warning"
echo "warning" | ./system_status.sh

## Тестирование со статусом "critical"
echo "critical" | ./system_status.sh

## Тестирование с недопустимым статусом
echo "unstable" | ./system_status.sh

## Тестирование с пустым вводом
echo "" | ./system_status.sh

Каждый ввод должен давать разный вывод в зависимости от условной логики в скрипте.

Тестирование числовых условий

На этом этапе вы научитесь использовать команду test для числовых сравнений. Это полезно для проверки использования ресурсов, валидации пользовательского ввода или принятия решений на основе числовых значений.

Общие операторы числового сравнения включают:

• -eq: Равно
• -ne: Не равно
• -lt: Меньше
• -le: Меньше или равно
• -gt: Больше
• -ge: Больше или равно

Начнем с некоторых базовых числовых сравнений:

## Сравнить два числа
num1=10
num2=20

## Равно
[ $num1 -eq 10 ] && echo "$num1 is equal to 10"

## Не равно
[ $num1 -ne $num2 ] && echo "$num1 is not equal to $num2"

## Меньше
[ $num1 -lt $num2 ] && echo "$num1 is less than $num2"

## Больше
[ $num2 -gt $num1 ] && echo "$num2 is greater than $num1"

## Меньше или равно
[ $num1 -le 10 ] && echo "$num1 is less than or equal to 10"

## Больше или равно
[ $num2 -ge 20 ] && echo "$num2 is greater than or equal to 20"

Вывод должен выглядеть так:

10 is equal to 10
10 is not equal to 20
10 is less than 20
20 is greater than 10
10 is less than or equal to 10
20 is greater than or equal to 20

Теперь создадим скрипт, который проверяет свободное место на диске и выводит предупреждение, если оно ниже определенного порога:

## Создать скрипт проверки свободного места на диске
cat > disk_check.sh << 'EOF'
#!/bin/bash

## Получить процент использования диска (убрать знак %)
DISK_USAGE=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

## Установить пороги
WARNING_THRESHOLD=70
CRITICAL_THRESHOLD=90

echo "Current disk usage: $DISK_USAGE%"

if [ $DISK_USAGE -ge $CRITICAL_THRESHOLD ]; then
  echo "CRITICAL: Disk usage is critically high!"
  echo "Action: Clean up unnecessary files immediately."
elif [ $DISK_USAGE -ge $WARNING_THRESHOLD ]; then
  echo "WARNING: Disk usage is getting high."
  echo "Action: Consider cleaning up some files soon."
else
  echo "OK: Disk usage is normal."
  echo "No action required."
fi
EOF

## Сделать скрипт исполняемым
chmod +x disk_check.sh

## Запустить скрипт
./disk_check.sh

Скрипт отобразит текущую загрузку диска и выведет разное сообщение в зависимости от степени заполнения диска.

Создадим еще один скрипт, который имитирует систему мониторинга температуры:

## Создать скрипт мониторинга температуры
cat > temp_monitor.sh << 'EOF'
#!/bin/bash

## Функция для генерации случайной температуры от 15 до 35
generate_temp() {
  echo $((RANDOM % 21 + 15))
}

## Сгенерировать случайную температуру
TEMP=$(generate_temp)
echo "Current temperature: ${TEMP}°C"

## Пороги температуры
MIN_TEMP=18
MAX_TEMP=26

if [ $TEMP -lt $MIN_TEMP ]; then
  echo "Action: Increase heating. Temperature is below minimum threshold."
elif [ $TEMP -gt $MAX_TEMP ]; then
  echo "Action: Activate cooling. Temperature is above maximum threshold."
else
  echo "Status: Temperature is within acceptable range."
fi

## Дополнительная проверка на экстремальные температуры
if [ $TEMP -ge 30 ]; then
  echo "WARNING: Temperature is very high. Check cooling systems."
fi
if [ $TEMP -le 17 ]; then
  echo "WARNING: Temperature is very low. Check heating systems."
fi
EOF

## Сделать скрипт исполняемым
chmod +x temp_monitor.sh

## Запустить скрипт
./temp_monitor.sh

Каждый раз, когда вы запускаете этот скрипт, он генерирует случайную температуру и реагирует соответствующим образом. Попробуйте запустить его несколько раз, чтобы увидеть разные результаты:

## Запустить скрипт мониторинга температуры несколько раз
./temp_monitor.sh
./temp_monitor.sh
./temp_monitor.sh

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

Объединение условий с помощью логических операторов

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

Три основных логических оператора:

• && (И): Истинно, если оба условия истинны
• || (ИЛИ): Истинно, если хотя бы одно условие истинно
• ! (НЕ): Истинно, если условие ложно

Начнем с некоторых базовых примеров:

## Создать тестовый файл
touch test_file.txt
chmod 644 test_file.txt

## Оператор И - оба условия должны быть истинными
[ -f test_file.txt ] && [ -r test_file.txt ] && echo "The file exists and is readable."

## Оператор ИЛИ - хотя бы одно условие должно быть истинным
[ -x test_file.txt ] || [ -w test_file.txt ] && echo "The file is either executable or writable."

## Оператор НЕ - инвертирует условие
[ ! -x test_file.txt ] && echo "The file is not executable."

## Комбинирование нескольких операторов
[ -f test_file.txt ] && [ -r test_file.txt ] && [ ! -x test_file.txt ] && echo "The file exists, is readable, but is not executable."

Вы должны увидеть вывод, похожий на следующий:

The file exists and is readable.
The file is either executable or writable.
The file is not executable.
The file exists, is readable, but is not executable.

Команда test также позволяет комбинировать условия в рамках одного набора скобок с использованием этих операторов:

• -a (И)
• -o (ИЛИ)

Например:

## Оператор И в рамках одной команды test
[ -f test_file.txt -a -r test_file.txt ] && echo "The file exists and is readable."

## Оператор ИЛИ в рамках одной команды test
[ -x test_file.txt -o -w test_file.txt ] && echo "The file is either executable or writable."

Создадим более сложный скрипт, который проверяет системные ресурсы:

## Создать скрипт проверки системных ресурсов
cat > resource_check.sh << 'EOF'
#!/bin/bash

echo "Checking system resources..."

## Проверить использование памяти
MEM_THRESHOLD=80
MEM_USED=$(free | grep Mem | awk '{print int($3/$2 * 100)}')

echo "Memory usage: ${MEM_USED}%"

## Проверить свободное место на диске
DISK_THRESHOLD=70
DISK_USED=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')

echo "Disk usage: ${DISK_USED}%"

## Проверить загрузку CPU (среднее за 1 минуту)
LOAD_THRESHOLD=1.0
CPU_LOAD=$(cat /proc/loadavg | awk '{print $1}')

echo "CPU load average: ${CPU_LOAD}"

## Комбинированная проверка условий
if [ $MEM_USED -gt $MEM_THRESHOLD ] && [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "CRITICAL: Both memory and disk usage are high!"
  echo "Action: Free up resources immediately."
elif [ $MEM_USED -gt $MEM_THRESHOLD ] || [ $DISK_USED -gt $DISK_THRESHOLD ]; then
  echo "WARNING: Either memory or disk usage is high."
  echo "Action: Monitor system closely."
else
  echo "OK: Memory and disk usage are within acceptable limits."
fi

## Проверить, является ли загрузка CPU числом перед сравнением
if [[ $CPU_LOAD =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
  ## Нам нужно использовать bc для сравнения с плавающей точкой
  if (( $(echo "$CPU_LOAD > $LOAD_THRESHOLD" | bc -l) )); then
    echo "WARNING: CPU load is high. Check for resource-intensive processes."
  else
    echo "OK: CPU load is normal."
  fi
else
  echo "Error: Could not parse CPU load value."
fi
EOF

## Сделать скрипт исполняемым
chmod +x resource_check.sh

## Запустить скрипт
./resource_check.sh

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

Наконец, создадим скрипт, который валидирует пользовательский ввод с использованием нескольких условий:

## Создать скрипт валидации ввода
cat > validate_input.sh << 'EOF'
#!/bin/bash

echo "Enter a username (lowercase letters only, 3-8 characters):"
read username

echo "Enter your age (must be 18 or older):"
read age

## Валидация имени пользователя
is_valid_username=true

## Проверить, пусто ли имя пользователя
if [ -z "$username" ]; then
  echo "Error: Username cannot be empty."
  is_valid_username=false
fi

## Проверить длину имени пользователя
if [ ${#username} -lt 3 ] || [ ${#username} -gt 8 ]; then
  echo "Error: Username must be between 3 and 8 characters."
  is_valid_username=false
fi

## Проверить, содержит ли имя пользователя только строчные буквы
if [[ ! "$username" =~ ^[a-z]+$ ]]; then
  echo "Error: Username must contain only lowercase letters."
  is_valid_username=false
fi

## Валидация возраста
is_valid_age=true

## Проверить, является ли возраст числом
if [[ ! "$age" =~ ^[0-9]+$ ]]; then
  echo "Error: Age must be a number."
  is_valid_age=false
fi

## Проверить, является ли возраст не менее 18 лет
if [ "$is_valid_age" = true ] && [ $age -lt 18 ]; then
  echo "Error: You must be at least 18 years old."
  is_valid_age=false
fi

## Финальная валидация
if [ "$is_valid_username" = true ] && [ "$is_valid_age" = true ]; then
  echo "Registration successful!"
  echo "Welcome, $username. Your account has been created."
else
  echo "Registration failed. Please correct the errors and try again."
fi
EOF

## Сделать скрипт исполняемым
chmod +x validate_input.sh

## Запустить скрипт
echo "You can test the script by running: ./validate_input.sh"

Попробуйте запустить скрипт с разными входными данными, чтобы увидеть, как комбинированные условия работают вместе для валидации пользовательского ввода:

## Тестирование с допустимым вводом
echo -e "john\n25" | ./validate_input.sh

## Тестирование с недопустимым именем пользователя (слишком коротким)
echo -e "jo\n25" | ./validate_input.sh

## Тестирование с недопустимым именем пользователя (содержит заглавные буквы)
echo -e "John\n25" | ./validate_input.sh

## Тестирование с недопустимым возрастом (менее 18 лет)
echo -e "john\n17" | ./validate_input.sh

## Тестирование с недопустимым возрастом (не число)
echo -e "john\nabc" | ./validate_input.sh

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

Создание комплексного скрипта мониторинга системы

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

Создадим скрипт, который будет отслеживать несколько аспектов системы:

## Создать скрипт мониторинга системы
cat > system_monitor.sh << 'EOF'
#!/bin/bash

echo "========================================"
echo "    System Monitoring Report"
echo "    $(date)"
echo "========================================"
echo

## 1. Проверить, существуют ли важные системные файлы
echo "1. System Files Check:"
important_files=("/etc/passwd" "/etc/hosts" "/etc/resolv.conf")
all_files_exist=true

for file in "${important_files[@]}"; do
  if [ -e "$file" ]; then
    echo "   [OK] $file exists"
    
    ## Проверить, пуст ли файл
    if [ ! -s "$file" ]; then
      echo "   [WARNING] $file is empty"
    fi
    
    ## Проверить, доступен ли файл для чтения
    if [ ! -r "$file" ]; then
      echo "   [WARNING] $file is not readable"
    fi
  else
    echo "   [ERROR] $file does not exist"
    all_files_exist=false
  fi
done

if [ "$all_files_exist" = true ]; then
  echo "   All system files are present."
else
  echo "   Some system files are missing. Check the errors above."
fi
echo

## 2. Проверить свободное место на диске
echo "2. Disk Space Check:"
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "   Root partition usage: ${disk_usage}%"

if [ $disk_usage -ge 90 ]; then
  echo "   [CRITICAL] Disk usage is critically high!"
elif [ $disk_usage -ge 70 ]; then
  echo "   [WARNING] Disk usage is getting high."
else
  echo "   [OK] Disk usage is normal."
fi
echo

## 3. Проверить использование памяти
echo "3. Memory Usage Check:"
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))

echo "   Memory usage: ${mem_percentage}% (${mem_used}MB used out of ${mem_total}MB)"

if [ $mem_percentage -ge 90 ]; then
  echo "   [CRITICAL] Memory usage is critically high!"
elif [ $mem_percentage -ge 70 ]; then
  echo "   [WARNING] Memory usage is getting high."
else
  echo "   [OK] Memory usage is normal."
fi
echo

## 4. Проверить активные процессы
echo "4. Process Check:"
critical_processes=("sshd" "cron")
for process in "${critical_processes[@]}"; do
  if pgrep -x "$process" > /dev/null; then
    echo "   [OK] $process is running"
  else
    echo "   [ERROR] $process is not running"
  fi
done
echo

## 5. Проверить загрузку системы
echo "5. System Load Check:"
load_1min=$(cat /proc/loadavg | awk '{print $1}')
load_5min=$(cat /proc/loadavg | awk '{print $2}')
load_15min=$(cat /proc/loadavg | awk '{print $3}')

echo "   Load average: $load_1min (1 min), $load_5min (5 min), $load_15min (15 min)"

## Определить количество ядер CPU
num_cores=$(grep -c ^processor /proc/cpuinfo)
load_threshold=$(echo "scale=2; $num_cores * 0.7" | bc)

if (( $(echo "$load_1min > $load_threshold" | bc -l) )); then
  echo "   [WARNING] High load detected. The system might be under stress."
else
  echo "   [OK] System load is normal."
fi
echo

## 6. Проверить недавние неудачные попытки входа
echo "6. Security Check:"
if [ -f /var/log/auth.log ]; then
  failed_logins=$(grep "Failed password" /var/log/auth.log | wc -l)
  echo "   Failed login attempts: $failed_logins"
  
  if [ $failed_logins -gt 10 ]; then
    echo "   [WARNING] High number of failed login attempts detected."
  else
    echo "   [OK] Normal login activity."
  fi
else
  echo "   [INFO] Cannot check login attempts (auth.log not accessible)"
fi
echo

## 7. Сводка
echo "7. System Status Summary:"
critical_count=$(grep -c "\[CRITICAL\]" <<< "$(cat /dev/stdin)")
warning_count=$(grep -c "\[WARNING\]" <<< "$(cat /dev/stdin)")
error_count=$(grep -c "\[ERROR\]" <<< "$(cat /dev/stdin)")

if [ $critical_count -gt 0 ]; then
  echo "   [CRITICAL] System has critical issues that need immediate attention!"
elif [ $warning_count -gt 0 ] || [ $error_count -gt 0 ]; then
  echo "   [WARNING] System has some issues that should be addressed soon."
else
  echo "   [OK] System is operating normally. No significant issues detected."
fi

echo
echo "========================================"
echo "    End of System Monitoring Report"
echo "========================================"
EOF

## Сделать скрипт исполняемым
chmod +x system_monitor.sh

## Запустить скрипт
./system_monitor.sh

Этот комплексный скрипт выполняет следующие проверки:

1. Проверяет, существуют ли важные системные файлы и доступны ли они для чтения.
2. Проверяет использование свободного места на диске.
3. Отслеживает использование памяти.
4. Подтверждает, что критически важные процессы запущены.
5. Оценивает загрузку системы.
6. Проверяет журналы безопасности на предмет неудачных попыток входа.
7. Предоставляет общую сводку о состоянии системы.

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

Для того чтобы сделать этот скрипт еще более полезным, вы можете:

1. Запланировать его периодическое выполнение с помощью cron.
2. Настроить отправку оповещений по электронной почте при обнаружении критических проблем.
3. Добавить более конкретные проверки, соответствующие вашей системе.

Создадим упрощенную версию, которую можно запланировать на периодическое выполнение:

## Создать упрощенный скрипт мониторинга для запланированного выполнения
cat > daily_check.sh << 'EOF'
#!/bin/bash

## Настроить файл журнала
LOG_FILE="/tmp/system_check_$(date +%Y%m%d).log"

## Начать запись в журнал
echo "System Check: $(date)" > $LOG_FILE
echo "--------------------------------" >> $LOG_FILE

## Проверить свободное место на диске
disk_usage=$(df -h / | grep / | awk '{print $5}' | sed 's/%//')
echo "Disk usage: ${disk_usage}%" >> $LOG_FILE

if [ $disk_usage -ge 90 ]; then
  echo "CRITICAL: Disk usage is critically high!" >> $LOG_FILE
elif [ $disk_usage -ge 70 ]; then
  echo "WARNING: Disk usage is getting high." >> $LOG_FILE
else
  echo "OK: Disk usage is normal." >> $LOG_FILE
fi

## Проверить память
mem_total=$(free -m | grep Mem | awk '{print $2}')
mem_used=$(free -m | grep Mem | awk '{print $3}')
mem_percentage=$((mem_used * 100 / mem_total))
echo "Memory usage: ${mem_percentage}%" >> $LOG_FILE

if [ $mem_percentage -ge 90 ]; then
  echo "CRITICAL: Memory usage is critically high!" >> $LOG_FILE
elif [ $mem_percentage -ge 70 ]; then
  echo "WARNING: Memory usage is getting high." >> $LOG_FILE
else
  echo "OK: Memory usage is normal." >> $LOG_FILE
fi

## Проверить критически важные сервисы
for service in sshd cron; do
  if pgrep -x "$service" > /dev/null; then
    echo "$service is running" >> $LOG_FILE
  else
    echo "WARNING: $service is not running" >> $LOG_FILE
  fi
done

## Закончить запись в журнал
echo "--------------------------------" >> $LOG_FILE
echo "Check completed at $(date)" >> $LOG_FILE

## Показать местоположение журнала
echo "System check completed. Log saved to $LOG_FILE"
EOF

## Сделать скрипт исполняемым
chmod +x daily_check.sh

## Запустить скрипт
./daily_check.sh

Для того чтобы запланировать выполнение этого скрипта ежедневно, обычно используется система cron. Вот как это можно настроить:

## Показать, как настроить задачу cron (не создавать ее в этой лабораторной среде)
echo "To schedule this script to run daily at 9 AM, you would use:"
echo "crontab -e"
echo "And add the line:"
echo "0 9 * * * /home/labex/project/daily_check.sh"

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

Резюме

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

1. Вы изучили основы команды test и научились проверять свойства файлов, такие как существование, доступность для чтения и размер.

2. Вы исследовали сравнение строк с использованием операторов, таких как ==, !=, -z и -n, для валидации ввода и принятия решений на основе текстового содержимого.

3. Вы работали с числовыми сравнениями, используя операторы, такие как -eq, -ne, -lt, -gt, -le и -ge, для оценки числовых значений.

4. Вы комбинировали несколько условий с помощью логических операторов (&&, ||, !) для создания сложной логики принятия решений.

5. Вы применили все эти техники для создания комплексных скриптов мониторинга системы, которые могут проверять различные системные параметры и предоставлять отчеты о состоянии.

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

Некоторые практические применения того, что вы узнали, включают:

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

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