Como executar comandos como em uma fila

Eu preciso fazer muitas cópias de vários arquivos em várias pastas. Posso adicionar todos os meus comandos de cópia a um script bash e executá-lo, mas devo esperar até que termine se desejar adicionar mais comandos à "fila" de cópia.

Existe uma maneira de executar comandos como uma fila e adicionar mais comandos a essa fila enquanto as coisas estão em execução?

Explicado de uma maneira diferente, quero iniciar uma tarefa de longa duração. Enquanto isso estiver em execução, quero iniciar outro que não seja iniciado até que o primeiro seja concluído. E depois adicione outro após o último e assim por diante. Isso é possível de alguma forma?

O atutilitário, mais conhecido por executar comandos em um horário especificado, também possui um recurso de fila e pode ser solicitado a iniciar a execução de comandos agora. Ele lê o comando para executar a partir da entrada padrão.

echo 'command1 --option arg1 arg2' | at -q myqueue now
echo 'command2 ...' | at -q myqueue now

O batchcomando é equivalente a at -q b -m now(o que -msignifica que a saída do comando, se houver, será enviada para você, como o cron). Nem todas as variantes do unix suportam nomes de fila ( -q myqueue); você pode estar limitado a uma única fila chamada b. O Linux até limitado a nomes de fila de uma letra.

Anexe &ao final do seu comando para enviá-lo para segundo plano e, waitem seguida , antes de executar o próximo. Por exemplo:

$ command1 &
$ wait; command2 &
$ wait; command3 &
$ ...

As soluções de Brad e Mankoff são boas sugestões. Outro que é semelhante a uma combinação dos dois seria usar o GNU Screen para implementar sua fila. Isso tem a vantagem de poder ser executado em segundo plano, você pode verificá-lo sempre que, e enfileirar novos comandos apenas os cola no buffer para serem executados após a saída dos comandos anteriores.

Primeira corrida:

$ screen -d -m -S queue

(aliás, agora é uma boa hora para brincar com alguns arquivos impressionantes. screenrc )

Isso gerará uma sessão de tela em segundo plano para você chamada fila.

Agora, coloque na fila quantos comandos desejar:

screen -S queue -X stuff "echo first; sleep 4; echo second^M"

Estou executando vários comandos no exemplo acima apenas para teste. Seu caso de uso provavelmente seria mais parecido com:

screen -S queue -X stuff "echo first^M"
screen -S queue -X stuff "echo second^M"

Observe que o "^ M" na minha linha acima é uma maneira de obter uma nova linha incorporada que será interpretada posteriormente depois que a tela a inserir no shell bash existente. Use "CTL-V" para obter essa sequência.

Seria muito fácil criar alguns scripts shell simples para automatizar isso e enfileirar comandos. Em seguida, sempre que desejar verificar o status da sua fila de segundo plano, reconecte-o via:

screen -S queue -r

Tecnicamente, você nem precisa nomear sua sessão de tela e ela funcionará bem, mas depois que você ficar viciado nela, você vai querer deixar uma funcionando o tempo todo. ;-)

Obviamente, se você fizer isso, outra boa maneira de fazer isso seria nomear uma das janelas atuais como "fila" e usar:

screen -S queue -p queue -X stuff "command"

Existe um utilitário que usei com grande sucesso exatamente para o caso de uso que você está descrevendo. Recentemente, mudei meu laptop principal para um novo hardware, que envolvia a transferência de alguns arquivos para um NAS e o restante para a nova máquina.

Foi assim que eu fiz.

1. Configure todas as máquinas envolvidas com uma conexão de rede para que elas possam se alcançar.

2. Na máquina de onde você está movendo os arquivos (a seguir denominada máquina de origem), instale o rsync com apt-get install rsynco spooler de tarefas de molho secreto (site http://vicerveza.homeunix.net/~viric/soft/ts/ ). Se você está no Debian, o nome do pacote tsé task-spoolere o executável é renomeado tsppara evitar conflitos de nomes com o tsexecutável do moreutilspacote. O pacote Debian vinculado a partir do site é perfeitamente instalável no Ubuntu com dpkg -i task-spooler_0.7.3-1_amd64.debou similar.

3. Verifique também se todas as máquinas possuem SSH instalado apt-get install openssh-server. Na máquina de origem, você precisa configurar o SSH para permitir o login sem senha nas máquinas de destino. O método mais utilizado será a autenticação de chave pública com ssh-agent(consulte https://www.google.se/search?q=ssh+public+key+authentication para exemplos disso), mas às vezes uso um método mais fácil que funciona apenas também com autenticação de senha. Adicione o seguinte à configuração do cliente SSH ( ~/.ssh/configou /etc/ssh/ssh_config):

   Host *
        ControlMaster auto
        ControlPath ~/.ssh/master-%r@%h:%p
   

   Em seguida, abra um terminal na máquina de origem, efetue login ssh target1, autentique como de costume e deixe esse terminal aberto. Observe que existe um arquivo de soquete nomeado ~/.ssh/master-user@target1:22, este é o arquivo que manterá aberta uma sessão mestre autenticada e permitirá conexões sem senha subseqüentes por user(desde que a conexão use o mesmo nome de host e porta de destino).

   Nesse ponto, você precisa verificar se é possível fazer login sem ser solicitado a autenticação nas máquinas de destino.

4. Agora execute ts rsync -ave ssh bigfile user@target1:um único arquivo ou ts rsync -ave ssh bigdir user@target1:um diretório. Com o rsync, é importante não incluir uma barra no diretório (em bigdircomparação com bigdir/) ou o rsync assumirá que você quis dizer o equivalente bigdir/*na maioria das outras ferramentas.

   O spooler de tarefas retornará o prompt e permitirá enfileirar muitos desses comandos em sucessão. Inspecione a fila de execução tssem argumentos.

O spooler de tarefas possui muitos recursos, como reorganizar a fila de execução, executar um trabalho específico apenas se outro trabalho foi executado com êxito, etc. Veja a ajuda com ts -h. Às vezes, inspeciono a saída do comando enquanto ele está sendo executado ts -c.

Existem outros métodos para fazer isso, mas para o seu caso de uso, todos incluem o spooler de tarefas. Eu escolhi usar o rsync sobre SSH para preservar os registros de data e hora do arquivo, que não seriam copiados pelo SMB.

Também preciso de coisas como essa com bastante frequência. Escrevi um pequeno utilitário chamado afterque executa um comando sempre que outro processo é concluído. Se parece com isso:

#!/usr/bin/perl

my $pid = shift;
die "Usage: $0 <pid> <command...>" unless $pid =~ /^\d+$/ && @ARGV;

print STDERR "Queueing process $$ after process $pid\n";
sleep 1 while -e "/proc/$pid";
exec @ARGV;

Você então executa da seguinte maneira:

% command1 arg1 arg2 ...  # creates pid=2853
% after 2853 command2 arg1 arg2 ... # creates pid=9564
% after 9564 command3 arg1 arg2 ...

A grande vantagem disso em relação a outras abordagens é que o primeiro trabalho não precisa ser executado de nenhuma maneira especial; você pode acompanhar qualquer processo com seu novo trabalho.

Command1 && Command2

• o "&&" significa que o comando2 é executado apenas após o comando1 terminar com um código de retorno 0
• Nota: a || significa que o comando2 é executado somente após o comando1 terminar com um código de retorno Diferente de 0

Você pode simplesmente adicionar comandos à linha de comando do shell que já está executando um comando.

Digite com cuidado ou em outro lugar, verifique e recorte e cole. Mesmo que o comando atual esteja exibindo linhas de saída, você ainda pode digitar algo novo, pressionar enter e ele será executado quando todos os comandos em execução ou digitados antes de serem concluídos.

O exemplo a seguir. Você pode recortar e colar a coisa toda ou inserir os comandos subseqüentes enquanto o primeiro estiver em execução (se você digitar realmente muito rápido), ou mais provavelmente enquanto o segundo estiver em execução .:

echo "foo"
sleep 10; echo "bar"
sleep 3
echo "baz"

a maneira mais hacki em que consigo pensar é manter a fila "state" com arquivos de bloqueio simples em / tmp. quando file1.sh estiver executando seus comandos cp, ele manterá um arquivo de bloqueio (ou hardlink) em / tmp. Quando terminar, apague o arquivo. todos os outros scripts terão que procurar em / tmp arquivos de bloqueio com o esquema de nomenclatura que você escolher. naturalmente, isso está sujeito a todos os tipos de falhas, mas é trivial de configurar e é factível completamente dentro do bash.