Início / unix / Perguntas / 767405
Accepted
Martin Vegter
Asked: 2024-01-21 15:07:19 +0800 CST

inicie várias janelas de terminal em um "grupo de processos" para que os processos restantes possam ser eliminados, se algum dos processos terminar

  • 772

Eu tenho um script que inicia 3 janelas do emulador de terminal:

#!/bin/sh

terminator --role='terminator-left' 2>/dev/null &
sleep 0.1
terminator --role='terminator-center' 2>/dev/null &
sleep 0.1
terminator --role='terminator-right' 2>/dev/null &

(Estou usando a opção --role, para poder colocar automaticamente as janelas em monitores diferentes, definidos no meu arquivo de configuração do openbox)

Eu inicio esse script várias vezes, em diferentes desktops virtuais.

Como posso iniciar esses 3 terminais em algum tipo de "grupo de processos", para poder encerrar todos os processos restantes, caso algum dos processos termine?

Importante: não quero encerrar todos os terminais que possam ter sido iniciados em uma instância diferente do meu script (não posso simplesmente usar pkill ou pgrep para encerrar qualquer processo que corresponda a um padrão)

Então, em outras palavras, digamos que eu inicie meu script na área de trabalho virtual 1 e na área de trabalho virtual 2.

Agora tenho 3 janelas de terminal em 2 desktops virtuais diferentes.

Quando saio de um terminal na área de trabalho virtual 1, gostaria que as 2 janelas restantes terminassem automaticamente, mas sem afetar a instância independente de outras 3 janelas em execução na minha área de trabalho virtual 2.

O que descrevo é possível?

Como posso conseguir isso?

shell-script

3 respostas

  1. Best Answer

    Isenção de responsabilidade:
    não tive oportunidade de testar minha sugestão no openbox. Eu o validei apenas no kde-plasma.
    Minha solução recorre ao waitcomando interno do shell , conforme documentado no manual dos programadores POSIX . Alguma implementação específica poderia tornar o script mais simples, usando a opção -n.

    #!/bin/sh

ownkill()
{
        trap - CHLD
        pkill --signal 15 -P $$ 
}

terminator --role='terminator-left' 2>/dev/null &
sleep 0.1
terminator --role='terminator-center' 2>/dev/null &
sleep 0.1
terminator --role='terminator-right' 2>/dev/null &
trap ownkill CHLD
wait

    Este script é baseado na ideia de:

    1. Inicie os 3 processos terminadores conforme desejado,
    2. Aguarde sua conclusão,
    3. Tratar o SIGCHLD sinalizando o encerramento de um dos processos acima de forma a encerrar os demais.

    Nota 1 (redefinindo o manipulador) : Conforme observado corretamente pelo aviro nos comentários, o manipulador de sinal deve redefinir o tratamento do SIGCHLD para os padrões, pois a eliminação dos processos restantes acionará outro (até 2) SIGCHLD.
    Não fazer isso forçaria o shell em algum tipo de situação recursiva (o manipulador tendo que lidar com um sinal que ele mesmo gerou) gerenciado de maneira mais ou menos elegante, dependendo das implementações do shell. (de um aviso inofensivo a alguma profundidade máxima de recursão excedida ou erro equivalente.)

    Nota 2 (Manter o tratamento padrão do SIGCHLD até a espera) : Conforme corretamente observado por Martin Vegter nos comentários, a trap ownkill CHLDinstrução deve ser colocada imediatamente antes da instrução de espera.
    Colocá-lo como a primeira instrução do script (como eu havia sugerido absurdamente em uma versão anterior) acionaria o manipulador dedicado assim que o primeiro sleepprocesso terminasse.

    • 3

  2. Usando o bash, você pode simplesmente coletar todos os ids do processo e esperar no final para que, quando qualquer processo terminar (bash's wait -n), todos os ids sejam eliminados com algum sinal adequado:

    #!/bin/bash
terminator --role='terminator-left' 2>/dev/null &
pid1=$!
sleep 0.1
terminator --role='terminator-center' 2>/dev/null &
pid2=$!
sleep 0.1
terminator --role='terminator-right' 2>/dev/null &
pid3=$!
wait -n
kill -hup $pid1 $pid2 $pid3 2>/dev/null

    Como um dos pids já estará morto, redirecionamos o killstderr para null para evitar uma mensagem de erro.

    • 2

  3. Você pode estar disposto a usar uma unidade transitória do systemd, pois é simples de iniciar, controlar e parar. Supondo que seu script de shell seja, digamos, ./myscriptadicione um wait -ncomando ao final dele para que não termine imediatamente, então você pode iniciá-lo com:

    systemd-run --user --unit=mytest1 ./myscript

    Este comando retorna imediatamente com a mensagem Running as unit: mytest1.service, e você pode ver quais processos estão sendo executados na unidade transitória criada com os comandos usuais:

    systemctl status --user mytest1

    Você pode interromper todos os processos com um comando:

    systemctl stop --user mytest1

    Para executar o mesmo script várias vezes, certifique-se de usar um --unit=nome diferente a cada vez. Se todos começarem com test, você poderá verificar todos eles ou interrompê-los referindo-se a eles como test*.

    Consulte man systemd-run para várias opções que podem ser úteis, como --setenv=, --working-directory=, --collect, --wait. Observe que você também pode passar argumentos para o seu script no final do systemd-runcomando.

    • 1

relate perguntas