Como desanexar um processo inteiramente do Terminal?

Eu uso o Tilda (terminal suspenso) no Ubuntu como minha "central de comandos" - da mesma forma que outras pessoas podem usar o GNOME Do, Quicksilver ou Launchy.

No entanto, estou lutando para desanexar completamente um processo (por exemplo, Firefox) do terminal do qual foi lançado - ou seja, impedir que esse processo (não) filho

• termina quando fecha o terminal de origem
• "polui" o terminal de origem via STDOUT / STDERR

Por exemplo, para iniciar o Vim em uma janela de terminal "adequada", tentei um script simples como o seguinte:

exec gnome-terminal -e "vim $@" &> /dev/null &

No entanto, isso ainda causa poluição (também, passar um nome de arquivo não parece funcionar).

Em primeiro lugar; Depois de iniciar um processo, você pode colocá-lo em segundo plano, primeiro parando-o (pressionar Ctrl- Z) e digitando bgpara deixá-lo retomar em segundo plano. Agora é um "trabalho" e seu stdout/ stderr/ stdinainda está conectado ao seu terminal.

Você pode iniciar um processo como segundo plano imediatamente anexando um "&" ao final dele:

firefox &

Para executá-lo em segundo plano silenciado, use o seguinte:

firefox </dev/null &>/dev/null &

Algumas informações adicionais:

nohupé um programa que você pode usar para executar seu aplicativo, de modo que seu stdout / stderr possa ser enviado para um arquivo e que o fechamento do script pai não SIGHUP o filho. No entanto, você precisa ter a previsão de usá-lo antes de iniciar o aplicativo. Por causa da maneira como nohupfunciona, você não pode simplesmente aplicá-lo a um processo em execução .

disowné um bash interno que remove um trabalho de shell da lista de trabalhos do shell. O que isto significa, basicamente, é que você não pode usar fg, bgno mais, mas o mais importante, quando você fecha o shell não irá travar ou enviar uma SIGHUPpara aquela criança mais. Ao contrário nohup, disowné usado após o processo ser iniciado e em segundo plano.

O que você não pode fazer é alterar o stdout / stderr / stdin de um processo depois de iniciá-lo. Pelo menos não da casca. Se você iniciar o seu processo e informar que o stdout é o seu terminal (que é o que você faz por padrão), esse processo está configurado para gerar saída para o seu terminal. Seu shell não se importa com a configuração de FD dos processos, isso é algo que o próprio processo gerencia. O processo em si pode decidir se deseja fechar seu stdout / stderr / stdin ou não, mas você não pode usar seu shell para forçá-lo a fazê-lo.

Para gerenciar a saída de um processo em segundo plano, você tem muitas opções de scripts, "nohup" provavelmente sendo o primeiro a se lembrar. Mas para processos interativos você inicia, mas esquece de silenciar ( firefox < /dev/null &>/dev/null &), na verdade não pode fazer muito.

Eu recomendo que você obtenha o GNU screen. Com a tela, você pode fechar o shell em execução quando a saída do processo se tornar um incômodo e abrir um novo ( ^Ac).

Ah, e a propósito, não use " $@" onde você estiver usando.

$@significa, $1, $2, $3..., que iria transformar o seu comando em:

gnome-terminal -e "vim $1" "$2" "$3" ...

Provavelmente não é isso que você quer, porque -e leva apenas um argumento. Use $1para mostrar que seu script pode lidar apenas com um argumento.

É realmente difícil fazer com que vários argumentos funcionem corretamente no cenário que você forneceu (com o gnome-terminal -e) porque -eleva apenas um argumento, que é uma sequência de comandos do shell. Você teria que codificar seus argumentos em um. A maneira melhor e mais robusta, mas bastante desajeitada, é a seguinte:

gnome-terminal -e "vim $(printf "%q " "$@")"

nohup cmd &

nohup desanexa completamente o processo (daemonizes)

Se você estiver usando bash, tente ; veja bash (1) .disown [jobspec]

Outra abordagem que você pode tentar é at now. Se você não é superusuário, sua permissão para uso atpode ser restrita.

Lendo essas respostas, tive a impressão inicial de que a emissão nohup <command> &seria suficiente. Executando o zsh no gnome-terminal, descobri que nohup <command> &não impedia meu shell de matar processos filhos na saída. Embora nohupseja útil, especialmente com shells não interativos, apenas garante esse comportamento se o processo filho não redefinir seu manipulador para o SIGHUPsinal.

No meu caso, nohupdeveria ter impedido que sinais de interrupção chegassem ao aplicativo, mas o aplicativo filho (VMWare Player neste caso) estava redefinindo seu SIGHUPmanipulador. Como resultado, quando o emulador de terminal sai, ele ainda pode matar seus subprocessos. Isso só pode ser resolvido, que eu saiba, garantindo que o processo seja removido da tabela de tarefas do shell. Se nohupfor substituído por um shell incorporado, como às vezes é o caso, isso pode ser suficiente, no entanto, no caso de não ser ...

disowné um escudo embutido no bash, zshe ksh93,

<command> &
disown

ou

<command> &; disown

se você preferir one-liners. Isso tem o efeito geralmente desejável de remover o subprocesso da tabela de tarefas. Isso permite que você saia do emulador de terminal sem sinalizar acidentalmente o processo filho. Independentemente da SIGHUPaparência do manipulador, isso não deve matar o processo filho.

Após a rejeição, o processo ainda é filho do seu emulador de terminal (brinque com pstreese você quiser assistir a isso em ação), mas após a saída do emulador de terminal, você deverá vê-lo anexado ao processo de inicialização. Em outras palavras, tudo está como deveria ser e como você provavelmente quer que seja.

O que fazer se o seu shell não suportar disown? Eu seria altamente recomendável mudar para um que sim, mas, na ausência dessa opção, você tem algumas opções.

1. screene tmuxpode resolver esse problema, mas são soluções muito mais pesadas e não gosto de executá-las para uma tarefa tão simples. Eles são muito mais adequados para situações nas quais você deseja manter um tty, normalmente em uma máquina remota.
2. Para muitos usuários, pode ser desejável verificar se o seu shell suporta um recurso como o zsh setopt nohup. Isso pode ser usado para especificar que SIGHUPnão deve ser enviado para os trabalhos na tabela de trabalhos quando o shell sair. Você pode aplicar isso imediatamente antes de sair do shell ou adicioná-lo à configuração do shell como ~/.zshrcse você sempre o quisesse.
3. Encontre uma maneira de editar a tabela de tarefas. Não consegui encontrar uma maneira de fazer isso no tcshou csh, o que é um pouco perturbador.
4. Escreva um pequeno programa em C para executar e exec(). Essa é uma solução muito ruim, mas a fonte deve consistir apenas em algumas dezenas de linhas. Você pode passar comandos como argumentos da linha de comando para o programa C e, assim, evitar uma entrada específica do processo na tabela de tarefas.

1. nohup $COMMAND &
2. $COMMAND & disown
3. setsid command

Eu uso o número 2 há muito tempo, mas o número 3 funciona da mesma forma. Além disso, disownpossui um nohupsinalizador de -h, pode negar todos os processos -ae pode negar todos os processos em execução -ar.

O silenciamento é realizado por $COMMAND &>/dev/null.

Espero que isto ajude!

Eu acho que a tela pode resolver seu problema

no tcsh (e talvez em outros shells também), você pode usar parênteses para desanexar o processo.

Compare isto:

> jobs # shows nothing
> firefox &
> jobs
[1]  + Running                       firefox

Para isso:

> jobs # shows nothing
> (firefox &)
> jobs # still shows nothing
>

Isso remove o firefox da lista de empregos, mas ainda está vinculado ao terminal; se você efetuou login neste nó via 'ssh', a tentativa de efetuar logout ainda trará o processo ssh.

Resposta mais simples e correta para o bash:

command & disown

_{Você não precisa desanexar o processo do terminal, mas do shell.}

Para desassociar o tty shell, execute o comando através do sub-shell, por exemplo

(comando)&

Quando o terminal usado sair fechado, mas o processo ainda está ativo.

Verifica -

(sleep 100) & exit

Abra outro terminal

ps aux | grep sleep

O processo ainda está vivo.

O background e o primeiro plano de um trabalho são provavelmente uma das primeiras coisas que todo administrador de sistemas Unix deve saber.

Aqui está como isso é feito com o bash:

./script.sh
# suspend process
{ctrl-Z}
# background process
bg
# list all backgrounded jobs
jobs
# bring it back to foreground
fg

Você pode executar seu comando usando o comando nohup, desanexando seu processo e redirecionando as saídas para um determinado arquivo ... mas não tenho certeza de que é exatamente isso que você precisa.

Experimente o daemon - deve estar disponível no seu amigável gerenciador de pacotes e cuidar de todas as maneiras de se desassociar do terminal.

Basta adicionar isso no seu bashrc / zshrc:

detach() {
  "$@" 1>/dev/null 2>/dev/null &; disown
}

Então você pode executar comandos renegados como este:

detach gedit ~/.zshrc

No meu .bashrc, tenho essas funções exatamente para esse fim:

function run_disowned() {
    "$@" & disown
}

function dos() {
    # run_disowned and silenced

    run_disowned "$@" 1>/dev/null 2>/dev/null
}

Prefixe um comando com dospara executá-lo desanexado do terminal.

A função foi escrita para trabalhar com bashe zsh.

Eu descobri no Mac OS X que preciso usar nohup AND disown para garantir que o processo filho não seja interrompido pelo terminal.

Eu uso o seguinte script para fazer isso. Ele interrompe a impressão do processo no terminal, desconecta nohupe sai com o status de retorno se o comando terminar dentro do TIMEOUT.

#!/bin/bash

TIMEOUT=0.1

CMD=( "$@" )
#Could have some shortcuts here, e.g. replace "somefile.c" with "gedit somefile.c"

#use nohup to run the command, suppressing its output and allowing the terminal to be closed
#also send nohup's output to /dev/null, supressing nohup.out
#run nohup in the background so this script doesn't block
#print the command for debugging and to see bash variable expansion
printf "%q " "${CMD[@]}"
echo
nohup "${CMD[@]}" >/dev/null 2>&1 &
NOHUP_PID=$!

#kill this script after a short time, exiting with success status - command is still running
#this is needed as there is no timeout argument for `wait` below
MY_PID=$$
trap "exit 0" SIGINT SIGTERM
sleep $TIMEOUT && kill $MY_PID 2>/dev/null & #ignore "No such process" error if this exits normally

#if the command finishes before the above timeout, everything may be just fine or there could have been an error
wait $NOHUP_PID
NOHUP_STATUS=$?
#print an error if there was any. most commonly, there was a typo in the command
[ $NOHUP_STATUS != 0 ] && echo "Error: $CMD"
#return the exit status of nohup, whatever it was
exit $NOHUP_STATUS

Exemplo de uso:

>>> run false
false
Error: false
>>> echo $?
1
>>> run true
true
>>> run sleep 10
sleep 10
>>>

sudo apt install ucommon-utils

pdetach command

Ai está :)

Muitas respostas sugeriram o uso de nohup . Prefiro sugerir o uso do pm2 . O uso do pm2 sobre nohup tem muitas vantagens, como manter o aplicativo ativo, manter arquivos de log para aplicativos e muito mais outros recursos. Para mais detalhes, verifique isso .

Para instalar o pm2, você precisa fazer o download do npm . Para sistema baseado em Debian

sudo apt-get install npm

e para Redhat

sudo yum install npm

Ou você pode seguir estas instruções . Após instalar o npm, use-o para instalar o pm2

npm install pm2@latest -g

Feito isso, você pode iniciar seu aplicativo

$ pm2 start app.js              # Start, Daemonize and auto-restart application (Node)
$ pm2 start app.py              # Start, Daemonize and auto-restart application (Python)

Para monitoramento de processo, use os seguintes comandos:

$ pm2 list                      # List all processes started with PM2
$ pm2 monit                     # Display memory and cpu usage of each app
$ pm2 show [app-name]           # Show all informations about application

Gerencie processos usando o nome do aplicativo ou a identificação do processo ou gerencie todos os processos juntos:

$ pm2 stop     <app_name|id|'all'|json_conf>
$ pm2 restart  <app_name|id|'all'|json_conf>
$ pm2 delete   <app_name|id|'all'|json_conf>

Os arquivos de log podem ser encontrados em

$HOME/.pm2/logs #contain all applications logs

Se seu objetivo é simplesmente iniciar um aplicativo de linha de comando sem manter a janela do terminal, tente executar o aplicativo depois de iniciar o terminal com alt-F2.