Cómo ejecutar comandos como en una cola

Necesito hacer muchas copias de varios archivos en varias carpetas. Puedo agregar todos mis comandos de copia a un script bash y luego ejecutar eso, pero luego debo esperar hasta que termine si quiero agregar más comandos a esa "cola" de copia.

¿Hay alguna forma de ejecutar comandos como una cola y agregar más comandos a esa cola mientras las cosas se están ejecutando?

Explicado de una manera diferente, quiero comenzar una tarea de larga duración. Mientras se está ejecutando, quiero iniciar otro que no se inicie hasta que se complete el primero. Y luego agregue otro después del último y así sucesivamente. ¿Es esto posible de alguna manera?

La atutilidad, mejor conocida por ejecutar comandos en un momento específico, también tiene una función de cola y se le puede pedir que comience a ejecutar comandos ahora. Lee el comando para ejecutar desde la entrada estándar.

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

El batchcomando es equivalente a at -q b -m now(lo que -msignifica que la salida del comando, si la hay, se le enviará por correo, como lo hace cron). No todas las variantes de Unix admiten nombres de cola ( -q myqueue); puede estar limitado a una sola cola llamada b. Linux atestá limitado a nombres de cola de una letra.

Agregue &al final de su comando para enviarlo al fondo, y luego waiten él antes de ejecutar el siguiente. Por ejemplo:

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

Las soluciones de Brad y Mankoff son buenas sugerencias. Otro que es similar a una combinación de ambos les sería utilizar GNU Screen para implementar su cola. Esto tiene la ventaja de poder ejecutarse en segundo plano, puede verificarlo cuando lo desee y poner en cola nuevos comandos simplemente los pega en el búfer para que se ejecuten después de que salgan los comandos anteriores.

Primer intento:

$ screen -d -m -S queue

(por cierto, ahora es un buen momento para jugar con algunos archivos impresionantes. screenrc )

Eso generará una sesión de pantalla de fondo para usted llamada cola.

Ahora, ponga en cola tantos comandos como desee:

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

Estoy haciendo múltiples comandos en lo anterior solo para probar. Su caso de uso probablemente se parecería más a:

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

Tenga en cuenta que la "^ M" en mi línea anterior es una forma de obtener una nueva línea incrustada que se interpretará más tarde después de que la pantalla la inserte en su shell de bash existente. Use "CTL-V" para obtener esa secuencia.

Sería bastante fácil crear algunos scripts de shell simples para automatizar eso y poner en cola los comandos. Luego, cada vez que desee verificar el estado de su cola en segundo plano, se vuelve a adjuntar a través de:

screen -S queue -r

Técnicamente, ni siquiera necesita nombrar su sesión de pantalla y funcionará bien, pero una vez que se enganche, querrá dejar una en ejecución todo el tiempo de todos modos. ;-)

Por supuesto, si haces eso, otra buena manera de hacerlo sería nombrar una de las ventanas actuales "cola" y usar:

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

Hay una utilidad que he utilizado con gran éxito exactamente para el caso de uso que está describiendo. Recientemente trasladé mi computadora portátil principal a un nuevo hardware, lo que implicó mover algunos archivos a un NAS y el resto a la nueva máquina.

Así es como lo hice.

1. Configure todas las máquinas involucradas con una conexión de red para que puedan comunicarse entre sí.

2. En la máquina desde la que está moviendo los archivos (en adelante, la máquina fuente), instale rsync con apt-get install rsyncy la Tarea Spooler de secret-sauce (sitio web http://vicerveza.homeunix.net/~viric/soft/ts/ ). Si está en Debian, el nombre del paquete tses is task-spoolery se cambia el tspnombre del tsejecutable para evitar el choque de nombres con el ejecutable del moreutilspaquete. El paquete Debian vinculado desde el sitio web es perfectamente instalable en Ubuntu con dpkg -i task-spooler_0.7.3-1_amd64.debo similar.

3. También asegúrese de que todas las máquinas tengan SSH instalado apt-get install openssh-server. En la máquina de origen, debe configurar SSH para permitir el inicio de sesión sin contraseña en las máquinas de destino. El método que la mayoría usará es la autenticación de clave pública con ssh-agent(consulte https://www.google.se/search?q=ssh+public+key+authentication para ver ejemplos de eso), pero a veces uso un método más fácil que funciona solo también con autenticación de contraseña. Agregue lo siguiente a la configuración de su cliente SSH (ya sea ~/.ssh/configo /etc/ssh/ssh_config):

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

   Luego abra una terminal en la máquina fuente, inicie sesión ssh target1, autentíquese como de costumbre y luego deje esta terminal abierta. Observe que hay un archivo de socket llamado ~/.ssh/master-user@target1:22, este es el archivo que mantendrá abierta una sesión maestra autenticada y permitirá conexiones sin contraseña posteriores user(siempre que la conexión use el mismo nombre de host y puerto de destino).

   En este punto, debe verificar que puede iniciar sesión sin que se le solicite la autenticación en las máquinas de destino.

4. Ahora ejecute ts rsync -ave ssh bigfile user@target1:para un solo archivo o ts rsync -ave ssh bigdir user@target1:para un directorio. Con rsync es importante no incluir una barra inclinada final en el directorio (en bigdircomparación con bigdir/) o rsync supondrá que se refería al equivalente de la bigdir/*mayoría de las otras herramientas.

   Task Spooler devolverá el mensaje y le permitirá poner en cola muchos de estos comandos en sucesión. Inspeccione la cola de ejecución tssin argumentos.

Task Spooler tiene muchas características, como reorganizar la cola de ejecución, ejecutar un trabajo específico solo si otro trabajo se ejecutó correctamente, etc. Consulte la ayuda con ts -h. A veces inspecciono la salida del comando mientras se ejecuta con ts -c.

Existen otros métodos para hacer esto, pero para su caso de uso, todos incluyen Task Spooler. Elijo usar rsync a través de SSH para preservar las marcas de tiempo del archivo, que la copia a través de SMB no tendría.

Necesito cosas como esta con bastante frecuencia también. Escribí una pequeña utilidad llamada afterque ejecuta un comando cada vez que algún otro proceso ha finalizado. Se parece a esto:

#!/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;

Luego lo ejecutas así:

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

La gran ventaja de esto sobre algunos otros enfoques es que el primer trabajo no necesita ejecutarse de ninguna manera especial, puede seguir cualquier proceso con su nuevo trabajo.

Command1 && Command2

• "&&" significa que el comando2 solo se ejecuta después de que el comando1 termina con un código de retorno de 0
• Nota: a || significa que command2 solo se ejecuta después de que command1 finaliza con un código de retorno que no sea 0

Simplemente puede agregar comandos a la línea de comandos del shell que ya está ejecutando un comando.

Escriba con cuidado o escríbalo en otro lugar, verifique y corte y pegue. Incluso si el comando actual arroja líneas de salida, puede escribir algo nuevo, presionar enter y se ejecutará cuando todos los comandos se ejecuten o ingresen antes de que se complete.

El siguiente ejemplo. Puede cortar y pegar todo, o ingresar los comandos posteriores mientras se ejecuta el primero (si escribe realmente muy rápido), o más probablemente mientras el segundo está en ejecución .:

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

La forma más complicada que se me ocurre es mantener el "estado" de la cola con simples archivos de bloqueo en / tmp. cuando file1.sh está haciendo sus comandos cp, mantendrá un archivo de bloqueo (o enlace duro) en / tmp. cuando termine, borre el archivo. cualquier otro script tendrá que buscar en / tmp los archivos de bloqueo con el esquema de nombres que elija. naturalmente, esto está sujeto a todo tipo de fallas, pero es trivial de configurar y se puede hacer completamente dentro de bash.