O kernel do Linux envia sinais aos processos sobre eventos aos quais eles precisam reagir. Scripts bem comportados lidam com sinais de maneira elegante e robusta e podem se limpar mesmo se você pressionar Ctrl+C. Veja como.
Índice
Sinais são mensagens curtas, rápidas e unidirecionais enviadas para processos como scripts, programas e daemons. Eles informam ao processo sobre algo que aconteceu. O usuário pode ter pressionado Ctrl+C ou o aplicativo pode ter tentado gravar na memória à qual não tem acesso.
Se o autor do processo previu que um determinado sinal poderia ser enviado a ele, ele poderá escrever uma rotina no programa ou script para lidar com esse sinal. Essa rotina é chamada de manipulador de sinal. Ele captura ou prende o sinal e executa alguma ação em resposta a ele.
O Linux usa muitos sinais, como veremos, mas do ponto de vista do script, há apenas um pequeno subconjunto de sinais nos quais você provavelmente estará interessado. Em particular, em scripts não triviais, sinais que informam ao O script para desligamento deve ser interceptado (quando possível) e um desligamento normal executado.
Por exemplo, scripts que criam arquivos temporários ou abrem portas de firewall podem ter a oportunidade de excluir os arquivos temporários ou fechar as portas antes que elas sejam encerradas. Se o script morrer no instante em que receber o sinal, seu computador poderá ficar em um estado imprevisível.
Veja como você pode lidar com sinais em seus próprios scripts.
Alguns comandos do Linux têm nomes enigmáticos. Não é assim com o comando que captura sinais. Chama-se trap
. Também podemos usar trap
com o
-l
(lista) opção para nos mostrar a lista completa de sinais que o Linux usa .
armadilha -l
Embora nossa lista numerada termine em 64, na verdade existem 62 sinais. Os sinais 32 e 33 estão faltando. Eles não são implementados no Linux . Eles foram substituídos pela funcionalidade do gcc
compilador para lidar com threads em tempo real. Tudo, desde o sinal 34, SIGRTMIN
até o sinal 64, SIGRTMAX
são sinais em tempo real.
Você verá listas diferentes em diferentes sistemas operacionais do tipo Unix. No OpenIndiana , por exemplo, os sinais 32 e 33 estão presentes, juntamente com vários sinais extras, elevando a contagem total para 73.
Os sinais podem ser referenciados por nome, número ou pelo nome abreviado. Seu nome abreviado é simplesmente o nome com o “SIG” inicial removido.
Os sinais são gerados por diversos motivos. Se você conseguir decifrá-los, seu propósito está contido em seu nome. O impacto de um sinal se enquadra em uma das seguintes categorias:
Estes são os sinais que você encontrará com mais frequência.
kill
comando foi usado com o sinal 2. Tecnicamente, este é um sinal de interrupção, não um sinal de encerramento, mas um script interrompido sem um o manipulador de sinal geralmente será encerrado.kill
comando foi usado com o sinal 3.SIGKILL
. SIGTERM
também diz a um processo para encerrar, mas ele pode ficar preso e o processo pode executar seus processos de limpeza antes de encerrar. Isso permite um desligamento normal. Este é o sinal padrão gerado pelo kill
comando.Uma maneira de capturar um sinal é usar trap
o número ou nome do sinal e uma resposta que você deseja que aconteça se o sinal for recebido. Podemos demonstrar isso em uma janela de terminal.
Este comando captura o SIGINT
sinal. A resposta é imprimir uma linha de texto na janela do terminal. Estamos usando a -e
opção (enable escapes) echo
para que possamos usar o \n
especificador de formato ” “.
trap 'echo -e "\nCtrl+c detectado."' SIGINT
Nossa linha de texto é impressa cada vez que pressionamos a combinação Ctrl+C.
Para ver se uma interceptação está definida em um sinal, use a -p
opção (print trap).
armadilha -p SIGINT
Usar trap
sem opções faz a mesma coisa.
Para redefinir o sinal para seu estado normal e não capturado, use um hífen ” -
” e o nome do sinal capturado.
armadilha - SIGINT
armadilha -p SIGINT
Nenhuma saída do trap -p
comando indica que não há nenhuma armadilha definida nesse sinal.
Podemos usar o mesmo trap
comando de formato geral dentro de um script. Este script captura três sinais diferentes, SIGINT
, SIGQUIT
e SIGTERM
.
#!/bin/bashtrap "echo I foi encerrado com SIGINT; exit" SIGINT
trap "echo I was SIGQUIT encerrado; exit" SIGQUIT
trap "echo I was SIGTERM encerrado; exit" SIGTERM
eco $$
contador=0
enquanto verdadeiro
fazer
echo "Número do loop:" $((++contador))
dormir 1
feito
As três trap
declarações estão no topo do script. Observe que incluímos o exit
comando na resposta a cada um dos sinais. Isso significa que o script reage ao sinal e sai.
Copie o texto em seu editor e salve-o em um arquivo chamado “simple-loop.sh”, e torne-o executável usando o chmod
comando . Você precisará fazer isso com todos os scripts deste artigo se quiser acompanhar em seu próprio computador. Basta usar o nome do script apropriado em cada caso.
chmod +x loop simples.sh
O resto do script é muito simples. Precisamos saber o ID do processo do script, para que o script repita isso para nós. A $$
variável contém o ID do processo do script.
Criamos uma variável chamada counter
e a definimos como zero.
O while
loop será executado para sempre, a menos que seja interrompido à força. Ele incrementa a counter
variável, faz eco na tela e dorme por um segundo.
Vamos executar o script e enviar sinais diferentes para ele.
./loop simples.sh
Quando pressionamos “Ctrl+C” nossa mensagem é impressa na janela do terminal e o script é finalizado.
Vamos executá-lo novamente e enviar o SIGQUIT
sinal usando o kill
comando. Precisaremos fazer isso em outra janela do terminal. Você precisará usar o ID do processo relatado pelo seu próprio script.
./loop simples.sh
matar -SIGQUIT 4575
Como esperado, o script relata que o sinal chega e termina. E finalmente, para provar isso, faremos novamente com o SIGTERM
sinal.
./loop simples.sh
matar -SIGTERM 4584
Verificamos que podemos capturar vários sinais em um script e reagir a cada um deles de forma independente. A etapa que transforma tudo isso de interessante em útil é adicionar manipuladores de sinal.
Podemos substituir a string de resposta pelo nome de uma função em seu script. O trap
comando então chama essa função quando o sinal é detectado.
Copie este texto em um editor e salve-o como um arquivo chamado “grace.sh”, e torne-o executável com a extensão chmod
.
#!/bin/basharmadilha Graceful_shutdown SIGINT SIGQUIT SIGTERM
Graceful_shutdown()
{
echo -e "\nRemovendo arquivo temporário:" $temp_file
rm -rf "$ arquivo_temp"
saída
}
arquivo_temp=$(mktemp -p /tmp tmp.XXXXXXXXXX)
echo "Arquivo temporário criado:" $temp_file
contador=0
enquanto verdadeiro
fazer
echo "Número do loop:" $((++contador))
dormir 1
feito
O script define uma armadilha para três sinais diferentes — SIGHUP
, SIGINT
e SIGTERM
— usando uma única trap
instrução. A resposta é o nome da graceful_shutdown()
função. A função é chamada sempre que um dos três sinais capturados é recebido.
O script cria um arquivo temporário no diretório “/tmp”, usando mktemp
. O modelo de nome de arquivo é “tmp.XXXXXXXXXX”, portanto o nome do arquivo será “tmp”. seguido por dez caracteres alfanuméricos aleatórios. O nome do arquivo é exibido na tela.
O resto do script é igual ao anterior, com uma counter
variável e um while
loop infinito.
./graça.sh
Quando o arquivo recebe um sinal que faz com que ele feche, a graceful_shutdown()
função é chamada. Isso exclui nosso único arquivo temporário. Em uma situação do mundo real, ele poderia realizar qualquer limpeza que seu script exigisse.
Além disso, agrupamos todos os nossos sinais capturados e os tratamos com uma única função. Você pode capturar sinais individualmente e enviá-los para suas próprias funções de manipulador dedicadas.
Copie este texto e salve-o em um arquivo chamado “triple.sh”, e torne-o executável usando o chmod
comando.
#!/bin/basharmadilha sigint_handler SIGINT
armadilha sigusr1_handler SIGUSR1
armadilha exit_handler SAIR
função sigint_handler() {
((++sigint_count))
echo -e "\nSIGINT recebeu $sigint_count tempo(s)."
if [[ "$sigint_count" -eq 3 ]]; então
echo "Iniciando fechamento."
loop_flag = 1
fi
}
função sigusr1_handler() {
echo "SIGUSR1 enviou e recebeu $((++sigusr1_count)) tempo(s)."
}
função exit_handler() {
echo "Manipulador de saída: o script está fechando..."
}
eco $$
sigusr1_count=0
sigint_count=0
loop_flag=0
enquanto [[ $loop_flag -eq 0 ]]; fazer
matar -SIGUSR1 $$
dormir 1
feito
Definimos três armadilhas no topo do script.
SIGINT
e tem um manipulador chamado sigint_handler()
.SIGUSR1
e usa um manipulador chamado sigusr1_handler()
.EXIT
sinal. Este sinal é gerado pelo próprio script quando ele é fechado. Definir um manipulador de sinal EXIT
significa que você pode definir uma função que sempre será chamada quando o script terminar (a menos que seja eliminado com signal SIGKILL
). Nosso manipulador é chamado exit_handler()
.SIGUSR1
e SIGUSR2
são sinais fornecidos para que você possa enviar sinais personalizados para seus scripts. Como você interpreta e reage a eles depende inteiramente de você.
Deixando os manipuladores de sinais de lado por enquanto, o corpo do script deve ser familiar para você. Ele ecoa o ID do processo na janela do terminal e cria algumas variáveis. A variável sigusr1_count
registra o número de vezes SIGUSR1
que foi manipulado e sigint_count
registra o número de vezes SIGINT
que foi manipulado. A loop_flag
variável é definida como zero.
O while
loop não é um loop infinito. Ele irá parar o loop se a loop_flag
variável for definida com qualquer valor diferente de zero. Cada rotação do while
loop kill
envia o SIGUSR1
sinal para este script, enviando-o para o ID do processo do script. Os scripts podem enviar sinais para si mesmos!
A sigusr1_handler()
função incrementa a sigusr1_count
variável e envia uma mensagem para a janela do terminal.
Cada vez que o SIGINT
sinal é recebido, a siguint_handler()
função incrementa a sigint_count
variável e ecoa seu valor na janela do terminal.
Se a sigint_count
variável for igual a três, a loop_flag
variável é definida como um e uma mensagem é enviada para a janela do terminal informando ao usuário que o processo de desligamento foi iniciado.
Como loop_flag
não é mais igual a zero, o while
loop termina e o script é finalizado. Mas essa ação aumenta automaticamente o EXIT
sinal e a exit_handler()
função é chamada.
./triplo.sh
Após três pressionamentos de Ctrl+C, o script termina e invoca automaticamente a exit_handler()
função.
Ao capturar sinais e lidar com eles em funções de manipulador simples, você pode fazer com que seus scripts Bash sejam organizados, mesmo que sejam encerrados inesperadamente. Isso fornece um sistema de arquivos mais limpo. Ele também evita a instabilidade na próxima vez que você executar o script e – dependendo da finalidade do seu script – pode até evitar falhas de segurança .
Muitos aplicativos de limpeza estão disponíveis para Windows ao longo dos anos, mas hoje em…
Seu PlayStation 4 está congelado? Seus jogos favoritos continuam travando? Reiniciar seu PS4 pode resolver…
A popularidade das mensagens de texto significou aprender uma forma totalmente nova de comunicação. Você…
A foto dos "Pilares da Criação" tirada pelo Telescópio Espacial Hubble é uma das fotos…
O Proton Drive saiu de seu estágio beta há algumas semanas, mas o aplicativo real…
Para ver suas fotos mais de perto ou para uma edição precisa , você pode…