Programa para poner en cola archivos para copiar / mover / eliminar en Linux?

Busqué en la red la respuesta de Linux a algo como Teracopy (Windows) ... pero no pude encontrar nada adecuado.

Las cosas más cercanas que tengo son:

• Krusader Mencionado en sus características pero indicado como 'aún no implementado'.
• Mini copiadora. Una aplicación basada en Java http://a.courreges.free.fr/projets/minicopier/minicopier-en.php
• rsync no es una opinión.

¿Alguien puede recomendarme una herramienta simple de copia de archivos que pueda poner en cola archivos para copiar / mover / eliminar? Preferiblemente si puedo arrastrar y soltar desde Nautilus.

Si algo como esto no existe, ¿alguien puede decirme por qué? ... ¿Soy la única persona que necesita algo como esto?

Acabo de escribir este script simple, que llamé 'cpw', para resolver este problema.

Lo usa de la misma manera que usaría cp ... la única diferencia es que crea una matriz de cualquier proceso de cpw que ya se está ejecutando cuando se inicia, y espera a que finalicen antes de pasar los comandos a cp. De esta manera, se comporta como una cola autoorganizada.

Puede seguir agregando trabajos cpw en segundo plano, pero no se pisarán entre sí. Ejecutarán uno a la vez.

Estoy seguro de que otros pueden sugerir mejoras.

#!/bin/bash

cpwpids=(`ps -ef | grep $USER | grep 'cpw' | grep -v grep | grep -v $$ | awk '{ print $2 }'`) #build an array of all cpw procs for this user that aren't this one.

cpwcnt=${#cpwpids[@]} # number of elemenets in the above array
cnt=$cpwcnt # counter to be decremented each pass
while [ $cnt -gt 0 ]
do
    cnt=$cpwcnt
    for i in "${cpwpids[@]}" # check if each pid has died yet
    do
        ps --pid $i >/dev/null
        if [ $? -gt 0 ]
        then
            let "cnt -= 1"
        fi
    done
    sleep 2
done
cp -v "$@" >> /tmp/cpw.log #log

Ejemplo de uso:

$ cpw -R /src/tree /dest/tree &

En mi experiencia, hacer algunas copias simultáneamente en Linux realmente no reduce el rendimiento general. Mi medición del rendimiento se basa en el argumento -P de rsync. Mi caso particular es copiar por separado varias carpetas llenas de archivos grandes de un disco duro USB al mismo tiempo.

Entonces, a menos que esté copiando muchas cosas a la vez, debería estar bien.

Dado que el guión proporcionado por Josh Arenberg podría tener algunos problemas de bloqueo (que no experimenté hasta ahora, pero que tampoco he investigado), he escrito algo por mi cuenta. No debería tener problemas de bloqueo. También funciona para cualquier comando de shell, no solo cp.

Contents of ~/bin/q

#!/bin/bash

#this waits for any PIDs to finish
anywait(){

    for pid in "$@"; do
        while kill -0 "$pid" 2&>1 >/dev/null; do
            sleep 0.5
        done
    done
}


PIDFILE=~/.q.pid

#open PIDFILE and aquire lock
exec 9>>$PIDFILE
flock -w2 9 || { echo "ERROR: flock() failed." >&2; exit 1; }

#read previous instances PID from PIDFILE and write own PID to PIDFILE
OLDPID=$(<$PIDFILE)
echo $$>$PIDFILE

#release lock
flock -u 9

#wait for OLDPID
anywait $OLDPID

#do stuff
"$@"


#afterwards: cleanup (if pidfile still contains own PID, truncate it)
flock -w2 9 || { echo "ERROR: flock() failed." >&2; exit 1; }
if [ $(<$PIDFILE) == $$ ]; then
truncate -s0 $PIDFILE
fi
flock -u 9

Crea una cadena de procesos, cada uno esperando el anterior. Si un proceso en el medio de la cadena se bloquea mientras espera (improbable pero no imposible), la cadena se rompe y ambas partes funcionan en paralelo. Lo mismo sucede si uno de los procesos es eliminado.

Uso como este:

q $COMMAND $ARGS

o incluso

q $COMMAND $ARGS; $ANOTHER_COMMAND $MORE_ARGS

Prueba, por ejemplo, escribiendo

q sleep 10 &
q echo blubb &

y descubriendo que después de 10 segundos se imprime blubb.

Ultracopier es el que desea, con el complemento Nemo o el complemento Nautilus .

No sé nada de esto para Linux (aunque eso no quiere decir que no haya uno en alguna parte). El software de Linux tiende a ser escrito por usuarios de Linux. Es posible que los usuarios experimentados de Linux no piensen en crear una herramienta como esta, porque si notan una ralentización de las copias durante una sesión de GUI, es probable que cambien a un terminal y copien a través de la línea de comandos.

Estas son algunas utilidades básicas de copia de línea de comandos que son muy rápidas y no deberían afectar su entorno de escritorio:

• cp ("cp foo / ruta / a / bar" copiará foo a la barra)
• mv ("mv foo / path / to / bar" se moverá (renombrará) foo a bar)
• tar ("tar cf - foo | (cd / path / to / archive /; tar xf -)" copiará recursivamente un directorio)
• rsync ("rsync -r foo / path / to / archive /" copiará recursivamente un directorio)

Cree una lista de archivos y use SCP para realizar la copia. Lo bueno de Linux es que puede agregar a su archivo de texto usando echo.

Encontré este proyecto de Unix Batch System llamado Task Spooler que le permite poner en cola las tareas.

• Arch linux
• Ubuntu

O puedes hacer sudo apt-get install task-spooler

Una vez instalado, simplemente puede colocar ts(o tsppara los sistemas Ubuntu / Debian) delante de cualquier comando de shell normal para ponerlo en cola.

Esta página tiene muchos ejemplos sobre sus usos: https://www.ostechnix.com/add-linux-commands-queue-execute-one-one/ o mira un video aquí: https://www.youtube.com / watch? v = wv8D8wT20ZY

Lo verifiqué y parece estar funcionando como se esperaba para todos mis cpcomandos.