Programma per accodare i file per Copia / Sposta / Elimina in Linux?

Ho cercato in rete la risposta di Linux a qualcosa come Teracopy (Windows) ... ma non sono riuscito a trovare nulla di adatto.

Le cose più vicine che ho sono:

• Krusader. Menzionato nelle loro caratteristiche ma indicato come 'non ancora implementato'.
• MiniCopier. Un'app basata su Java http://a.courreges.free.fr/projets/minicopier/minicopier-en.php
• rsync non è un'opzione.

Qualcuno può consigliarmi un semplice strumento di copia file in grado di mettere in coda i file per copiare / spostare / eliminare? Preferibilmente se posso trascinare e rilasciare da Nautilus.

Se qualcosa del genere non esiste, qualcuno può dirmi perché? ... sono l'unica persona che ha bisogno di qualcosa del genere?

Ho appena scritto questo semplice script, che ho chiamato 'cpw', per risolvere questo problema.

Lo usi proprio come faresti con cp ... l'unica differenza è che crea un array di tutti i processi cpw che sono già in esecuzione all'avvio, e attende che finiscano prima di passare i comandi a cp. In questo modo, si comporta come una coda auto-organizzata.

Puoi continuare ad aggiungere lavori in background cpw, ma non si faranno un passo a vicenda. Eseguiranno uno alla volta.

Sono sicuro che altri possano suggerire miglioramenti.

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

Esempio di utilizzo:

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

Nella mia esperienza, fare alcune copie simultaneamente in Linux non riduce realmente il throughput complessivo. La mia misurazione del throughput si basa sull'argomento -P di rsync. Il mio caso particolare è la copia separata di un numero di cartelle piene di file di grandi dimensioni da un disco rigido USB contemporaneamente.

Quindi, a meno che tu non stia copiando molte cose contemporaneamente, dovresti andare bene.

Dal momento che la sceneggiatura di Josh Arenberg potrebbe avere alcuni problemi di deadlock (che non ho sperimentato finora, ma che non ho studiato), ho scritto qualcosa per conto mio. Non dovrebbe avere problemi di deadlock. Funziona anche con qualsiasi comando shell, non 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 catena di processi, ognuno in attesa di quello precedente. Se un processo nel mezzo della catena si arresta in modo anomalo durante l'attesa (improbabile ma non impossibile), la catena si rompe ed entrambe le parti funzionano in parallelo. Lo stesso accade se uno dei processi viene ucciso.

Uso come questo:

q $COMMAND $ARGS

o anche

q $COMMAND $ARGS; $ANOTHER_COMMAND $MORE_ARGS

Prova ad esempio digitando

q sleep 10 &
q echo blubb &

e scoprendo che dopo 10 secondi viene stampato il blubb.

Ultracopier è quello che si desidera, con Nemo plug-in o Nautilus plug-in .

Non so nulla di simile per Linux (anche se questo non vuol dire che non ce ne sia uno da qualche parte). Il software Linux tende a essere scritto dagli utenti Linux. Gli utenti Linux esperti potrebbero non pensare di creare uno strumento come questo, perché se notano un rallentamento delle copie durante una sessione della GUI, è probabile che passino a un terminale e copino tramite riga di comando.

Ecco alcune utility di base per la copia da riga di comando che sono molto veloci e non dovrebbero influire sull'ambiente desktop:

• cp ("cp foo / path / to / bar" copierà foo in bar)
• mv ("mv foo / path / to / bar" sposta (rinomina) foo in bar)
• tar ("tar cf - foo | (cd / path / to / archive /; tar xf -)" copierà ricorsivamente una directory)
• rsync ("rsync -r foo / path / to / archive /" copierà ricorsivamente una directory)

Creare un elenco di file e utilizzare SCP per eseguire la copia. La cosa bella di Linux è che puoi aggiungere al tuo file di testo usando echo.

Ho trovato questo progetto Unix Batch System chiamato Task Spooler che ti consente di mettere in coda le attività.

• Arch Linux
• Ubuntu

Oppure puoi farlo sudo apt-get install task-spooler

Una volta installato, puoi semplicemente mettere ts(o tspper i sistemi Ubuntu / Debian) davanti a qualsiasi normale comando shell per metterlo in coda.

Questa pagina contiene molti esempi sui suoi usi: https://www.ostechnix.com/add-linux-commands-queue-execute-one-one/ oppure guardi un video qui: https://www.youtube.com / watch? v = wv8D8wT20ZY

L'ho verificato e sembra funzionare come previsto per tutti i miei cpcomandi.