Byobu: Matar processo em primeiro plano na janela atual

Vamos utilizar bindkeypara criar um atalho e comandos internos pgrepe pkill. Como informação/demonstração adicional, usarei pscom algumas de suas opções.

Vamos:

1. pstem alguns parâmetros interessantes, aqueles nos quais vamos nos concentrar são T, -C <command name>e -o pid=(sim, nada depois =!).

OBSERVAÇÃO: todo este parágrafo tem o objetivo de ser uma demonstração, uma maneira de verificar facilmente a correção da solução real no próximo.

• ps Timprime processos em execução no terminal atual . Como exemplo, criei um symlink temporário /bin/phpspara meu PhpStorm, então a execução phps &abre uma instância do IDE mencionado em segundo plano. Depois de executá-lo em um terminal ( >/dev/null 2>&1adicionado para que não imprima nada, &significa "executar em segundo plano"):

  

  (você também pode notar que o número de trabalhos em segundo plano em execução no terminal atual mudou de verde 0para vermelho !1!)
  Agora, veja como fica no segundo terminal:

  

• Agora vamos tentar ps -C <command name>- colocar meu phps como um comando pesquisado:

  

  e no outro terminal temos:

  

  Note que o segundo terminal é pts/0(confira a imagem anterior), mas em ambos recebemos pts/1como resultado (corretamente!) - já que é o terminal em que estamos executando nosso comando.
  Por causa desse comportamento, comecei com ps T- para que possamos capturar o PIDdo processo em execução no terminal atual .

• O último parâmetro que eu gostaria de elaborar é -o pid=. É um modificador de saída que simplesmente faz a psimpressão somente de PIDs, sem o cabeçalho (primeira linha). A maneira mais fácil de explicar é sempre a maneira visual:

  

• Então - a última coisa a fazer aqui é combinar tudo acima. Vamos simplesmente usar ps -C phps -o pid= on a result of ps T :

  

  e no outro terminal:

  

  Como podemos ver, alcançamos o resultado esperado: podemos capturar o PID de um processo escolhido, mas somente se ele estiver em execução no terminal atual.

2. Minha solução real é baseada nos comandos 'pgrep' e 'pkill', pois eles se encaixam melhor, mas observe que usar os mencionados acima pstambém funcionaria.

O principal motivo para o uso pgrepé seu parâmetro interno -s 0, documentado como "Corresponde apenas aos processos cujo ID de sessão do processo está listado. O ID de sessão 0 é traduzido no ID de sessão do próprio pgrep ou pkill" .

• Então, vamos ver em ação:

  

  e no segundo terminal:

  

  Como mostrado - podemos conseguir o que fizemos antes com ps, mas com um único comando. pkillé irmão de pgrep, então ele pega os mesmos parâmetros. Vamos ver como funciona - no segundo terminal :

  

  Como esperado - não matou o processo, porque ele não pertence ao terminal atual. Agora para o console principal:

  

  Então - finalmente alcançamos o resultado que queríamos. O último passo é vincular nosso comando a um atalho.

  Para criá-lo para zsh usaremos o seguinte comando:

  bindkey -s '^k' 'pkill <YOUR ACTUAL BINARY> -s 0\n'
  

  (este exemplo em particular vincula o comando à combinação CTRL+k)

  Depois, basta adicioná-lo ao seu ~/.zshrcou /etc/zsh/zshrc(para fornecimento global) e pronto.

Bônus : Observe que pkill(e também killpara o assunto de fato) envia SIGTERMsinal por padrão (se nenhum for especificado), e se seu processo aceitar outros sinais, você pode facilmente utilizá-lo usando --signal <NAME>como um parâmetro adicional para pkill. O propósito disso é, por exemplo, fechar o processo graciosamente . Normalmente, a lista de sinais que o daemon em particular aceita é listada em man <NAME>, na SIGNALSseção. Exemplo de man stunnel:

SIGNALS
       The following signals can be used to control stunnel in Unix environment:
       SIGHUP
           Force a reload of the configuration file.
           Some global options will not be reloaded:
           ·   chroot
           ·   foreground
           ·   pid
           ·   setgid
           ·   setuid
           The use of the 'setuid' option will also prevent stunnel from binding to privileged (<1024) ports during configuration reloading.
           When the 'chroot' option is used, stunnel will look for all its files (including the configuration file, certificates, the log file and the pid file) within the chroot
           jail.
       SIGUSR1
           Close and reopen the stunnel log file.  This function can be used for log rotation.
       SIGUSR2
           Log the list of active connections.
       SIGTERM, SIGQUIT, SIGINT
           Shut stunnel down.

A lista de sinais disponíveis pode ser facilmente acessada usando kill -lo comando.

Então, se você quiser usar o equivalente a ie kill -9 <PROCESS>(que é igual a kill -SIGKILL <PROCESS>) - basta adicionar --signal SIGKILL(ou simplesmente: -9) ao seu pkillcomando.

~/bin/_byobu_kill_process.sh:

#!/bin/bash

window_id=$(tmux display-message -p '#I')

pane_id=$(tmux list-panes -t :$window_id -F '#{pane_active}#D' | grep '^1' | cut -c 2-)

fg_pid=$(tmux display-message -t :$window_id.$pane_id -p '#{pane_pid}' | xargs pgrep -P | xargs ps -o stat,pid= -p | grep '+' | awk '{print $2}')

if [ -z "$fg_pid" ]; then
    echo "No foreground process found in window $window_id"
    exit 1
fi

get_child_pids() {
    local parent_pid="$1"
    local child_pids=$(pgrep -P "$parent_pid")
    for pid in $child_pids; do
        echo "$pid"
        get_child_pids "$pid"
    done
}

pids_to_kill=$(echo "$fg_pid"; get_child_pids "$fg_pid")

processes_info=$(ps -o pid=,ppid=,comm= -p $pids_to_kill)

for pid in $pids_to_kill; do
    kill -9 "$pid" 2>/dev/null
done

~/.bybou/keybindings.tmux:

unbind-key k
bind-key k run '~/bin/_byobu_kill_process.sh'

Sim, você pode criar uma tecla de atalho Byobu personalizada para matar o processo em primeiro plano na janela Byobu atualmente ativa. Veja como você pode configurá-la:

1. Crie um script para matar o processo em primeiro plano Você precisará escrever um pequeno script que identifique o processo em primeiro plano na janela ativa do Byobu e envie a ele um sinal de eliminação -9.

2. Crie um arquivo chamado kill_foreground_process.sh no seu diretório home (ou onde você preferir):

   #!/bin/bash
   
   # Get the Byobu window number of the currently active window
   window=$(tmux display-message -p '#I')
   
   # Get the process ID (PID) of the foreground process running in the current window
   pid=$(tmux list-panes -F '#{pane_active} #{pane_pid}' | grep '^1 ' | awk '{print $2}')
   
   # If a PID was found, kill the process
   if [ -n "$pid" ]; then
       kill -9 "$pid"
       echo "Killed process with PID $pid"
   else
       echo "No active foreground process found."
   fi