Programación en Bash: El Comando Trap para la Gestión de Señales

Introducción

En esta sesión práctica, exploraremos el comando trap en la programación de scripts de Bash. El comando trap es una herramienta sumamente potente que permite capturar y gestionar señales, interrupciones y entradas del usuario durante la ejecución de tus scripts. Al utilizar trap, puedes definir acciones específicas que se ejecutarán cuando se reciban señales particulares, lo que te permite controlar comportamientos inesperados y finalizar procesos de manera ordenada. Esta práctica está diseñada para principiantes y te guiará paso a paso para que aprendas a utilizar el comando trap de forma eficaz.

Crear un Script de Bash

Comencemos creando un nuevo archivo de script de Bash donde implementaremos el comando trap.

Abre una terminal en el WebIDE. Deberías ver un cursor que termina con el símbolo $.
Dirígete al directorio del proyecto:
```
cd ~/project
```
Este comando cambia tu directorio de trabajo actual a /home/labex/project.
Crea un nuevo archivo llamado trap_example.sh:
```
touch trap_example.sh
```
El comando touch crea un archivo vacío si no existe, o actualiza la fecha de modificación si ya existe.
Abre el archivo trap_example.sh en el editor del WebIDE. Puedes hacerlo haciendo clic en el nombre del archivo en el explorador de archivos situado en el lado izquierdo del WebIDE.

Implementar un Comando Trap Básico

Ahora, vamos a implementar un comando trap básico en nuestro script para capturar señales específicas y salir del programa de forma controlada.

Añade el siguiente contenido al archivo trap_example.sh:
```
#!/bin/bash

cleanup_and_exit() {
  echo -e "\nSignal received! Cleaning up and exiting..."
  exit 0
}

trap cleanup_and_exit SIGINT SIGTERM

echo "This script will run until you press Ctrl+C."
echo "Press Ctrl+C to see the trap in action and exit gracefully."

count=1
while true; do
  echo "Script is running... (iteration $count)"
  sleep 1
  ((count++))
done
```
Analicemos los componentes de este script:
- La primera línea #!/bin/bash se conoce como shebang. Indica al sistema que este script debe ser ejecutado por el intérprete de comandos Bash.
- Definimos una función llamada cleanup_and_exit que imprime un mensaje y finaliza el script.
- El comando trap se configura para invocar a cleanup_and_exit cuando detecta las señales SIGINT (interrupción) o SIGTERM (terminación). SIGINT se envía normalmente cuando presionas Ctrl+C, mientras que SIGTERM se utiliza a menudo cuando se solicita a un proceso que termine de manera ordenada.
- Los comandos echo muestran instrucciones para el usuario.
- El bucle while se ejecuta indefinidamente, imprimiendo un mensaje e incrementando un contador cada segundo.
Guarda el archivo después de añadir el contenido.

Dar Permisos de Ejecución al Script y Ejecutarlo

Antes de poder ejecutar nuestro script, necesitamos otorgarle permisos de ejecución. Esto le indica al sistema que este archivo puede ejecutarse como un programa.

En la terminal, haz que el script sea ejecutable:
```
chmod +x ~/project/trap_example.sh
```
El comando chmod cambia los permisos de un archivo. La opción +x añade el permiso de ejecución.
Ejecuta el script:
```
~/project/trap_example.sh
```
Este comando le indica a Bash que inicie la ejecución de nuestro script.
El script comenzará a ejecutarse. Verás las instrucciones impresas en pantalla. Déjalo funcionar durante unos segundos.
Ahora, presiona Ctrl+C para interrumpirlo. Deberías ver el mensaje "Signal received!" justo antes de que el script finalice. ¡Aquí es donde nuestro trap entra en acción!

Modificar el Trap para Usar una Función Compleja

En lugar de una función simple, vamos a modificar nuestro script para emplear una función más elaborada con el comando trap. Esto nos permite realizar acciones más detalladas cuando se recibe una señal.

Abre el archivo trap_example.sh en el editor del WebIDE.
Sustituye el contenido del archivo por el siguiente:
```
#!/bin/bash

cleanup_and_exit() {
  echo -e "\nSignal received! Cleaning up..."
  echo "Performing cleanup tasks..."
  ## Add any necessary cleanup code here
  echo "Cleanup completed."
  echo "Exiting script gracefully."
  exit 0
}

trap cleanup_and_exit SIGINT SIGTERM

echo "This script will run until you press Ctrl+C."
echo "Press Ctrl+C to see the trap function in action and exit gracefully."

count=1
while true; do
  echo "Script is running... (iteration $count)"
  sleep 1
  ((count++))
done
```
Examinemos los cambios realizados:
- Hemos ampliado la función cleanup_and_exit para incluir mensajes más detallados y un espacio reservado para tareas de limpieza.
- La función ahora simula un proceso de limpieza más realista, que podría incluir tareas como cerrar descriptores de archivos, eliminar archivos temporales o liberar otros recursos del sistema.
- Hemos actualizado el bucle principal para mostrar un contador de iteraciones, lo que hace más evidente que el script está funcionando activamente.
Guarda el archivo tras realizar estos cambios.
Ejecuta el script de nuevo y pruébalo presionando Ctrl+C:
```
~/project/trap_example.sh
```
Al interrumpir el script, deberías ver los nuevos mensajes de la función cleanup_and_exit, demostrando una salida elegante y controlada.

Resumen

En esta práctica de laboratorio, has aprendido a utilizar el comando trap en scripts de Bash. Has creado un script capaz de capturar señales específicas y definir acciones a realizar cuando dichas señales son recibidas. También has explorado diferentes formas de emplear el comando trap, incluyendo el uso de comandos directos y funciones personalizadas.

El comando trap es una herramienta fundamental para gestionar interrupciones y realizar tareas de limpieza en tus scripts de Bash. Te permite desarrollar aplicaciones de línea de comandos más robustas y profesionales al manejar adecuadamente las terminaciones inesperadas y las interrupciones del usuario.

Recuerda que la capacidad de gestionar señales es crucial en muchos escenarios de automatización, como garantizar la eliminación correcta de archivos temporales, cerrar conexiones de red o guardar el estado actual antes de que un script finalice de forma imprevista.

Comando Trap de Bash