Scripting em Bash: O Comando Trap para Manipulação de Sinais

Introdução

Neste laboratório, vamos explorar o comando trap no scripting em Bash. O comando trap é uma ferramenta poderosa que permite capturar e lidar com sinais, interrupções e entradas do usuário em seus scripts. Ao usar o trap, você pode definir ações específicas a serem executadas quando sinais particulares são recebidos, permitindo gerenciar comportamentos imprevisíveis e lidar de forma elegante com diversos cenários. Este laboratório foi projetado para iniciantes e guiará você pelo processo de uso eficaz do comando trap.

Criar um Script Bash

Vamos começar criando um novo arquivo de script Bash onde implementaremos o comando trap.

Abra um terminal no WebIDE. Você verá um prompt terminando com o símbolo $.
Navegue até o diretório do projeto:
```
cd ~/project
```
Este comando altera seu diretório de trabalho atual para /home/labex/project.
Crie um novo arquivo chamado trap_example.sh:
```
touch trap_example.sh
```
O comando touch cria um arquivo vazio se ele não existir, ou atualiza a data de modificação caso ele já exista.
Abra o arquivo trap_example.sh no editor do WebIDE. Você pode fazer isso clicando no nome do arquivo no explorador de arquivos no lado esquerdo da interface.

Implementar um Comando Trap Básico

Agora, vamos implementar um comando trap básico em nosso script para capturar sinais específicos e encerrar a execução de forma limpa.

Adicione o seguinte conteúdo ao arquivo 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
```
Vamos detalhar o que este script faz:
- A primeira linha #!/bin/bash é chamada de shebang. Ela informa ao sistema que este script deve ser executado pelo shell Bash.
- Definimos uma função chamada cleanup_and_exit que exibe uma mensagem e encerra o script.
- O comando trap é configurado para chamar a função cleanup_and_exit quando detectar os sinais SIGINT (interrupção) ou SIGTERM (terminação). O SIGINT geralmente é enviado quando você pressiona Ctrl+C, enquanto o SIGTERM é frequentemente usado quando se solicita que um processo termine de forma amigável.
- Os comandos echo imprimem instruções para o usuário.
- O loop while executa indefinidamente, exibindo uma mensagem e incrementando um contador a cada segundo.
Salve o arquivo após adicionar o conteúdo.

Tornar o Script Executável e Executá-lo

Antes de podermos rodar nosso script, precisamos torná-lo executável. Isso informa ao sistema que este arquivo tem permissão para ser executado como um programa.

No terminal, torne o script executável:
```
chmod +x ~/project/trap_example.sh
```
O comando chmod altera as permissões de um arquivo. A opção +x adiciona a permissão de execução.
Execute o script:
```
~/project/trap_example.sh
```
Este comando solicita que o Bash execute o nosso script.
O script começará a rodar. Você verá as instruções impressas na tela. Deixe-o rodar por alguns segundos.
Agora, pressione Ctrl+C para interrompê-lo. Você deverá ver a mensagem "Signal received!" antes do script fechar. Este é o nosso trap em ação!

Modificar o Trap para Usar uma Função

Em vez de usar uma função simples, vamos modificar nosso script para utilizar uma função mais complexa com o comando trap. Isso nos permite realizar ações mais detalhadas quando um sinal é recebido.

Abra o arquivo trap_example.sh no editor do WebIDE.
Substitua o conteúdo do arquivo pelo seguinte:
```
#!/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
```
Vamos analisar as mudanças:
- Expandimos a função cleanup_and_exit para incluir mensagens mais detalhadas e um espaço reservado para tarefas de limpeza.
- A função agora simula um processo de limpeza mais realista, que poderia incluir tarefas como fechar manipuladores de arquivos, remover arquivos temporários ou liberar outros recursos.
- Atualizamos o loop principal para mostrar a contagem de iterações, tornando mais claro que o script está ativamente em execução.
Salve o arquivo após realizar essas alterações.
Execute o script novamente e teste-o pressionando Ctrl+C:
```
~/project/trap_example.sh
```
Você deverá ver as novas mensagens da função cleanup_and_exit ao interromper o script, demonstrando um encerramento elegante.

Resumo

Neste laboratório, você aprendeu como usar o comando trap no scripting em Bash. Você criou um script que captura sinais específicos e define ações a serem tomadas quando esses sinais são recebidos. Você explorou diferentes formas de usar o comando trap, incluindo o uso de comandos em linha e funções.

O comando trap é uma ferramenta essencial para lidar com interrupções e realizar ações de limpeza em seus scripts Bash. Ele permite criar aplicações de linha de comando mais robustas e amigáveis ao usuário, gerenciando de forma controlada encerramentos inesperados e interrupções do usuário.

Lembre-se de que a capacidade de manipular sinais pode ser crucial em muitos cenários de automação, como garantir a limpeza adequada de arquivos temporários, fechar conexões de rede ou salvar o estado antes que um script termine abruptamente.

Comando Trap no Bash