Programme pour mettre en file d'attente des fichiers pour copier / déplacer / supprimer sous Linux?

J'ai cherché sur le net la réponse de Linux à quelque chose comme Teracopy (Windows) ... mais je n'ai rien trouvé de convenable.

Les choses les plus proches que j'ai obtenues sont:

• Krusader. Mentionné dans leurs caractéristiques mais indiqué comme «pas encore implémenté».
• MiniCopier. Une application basée sur java http://a.courreges.free.fr/projets/minicopier/minicopier-en.php
• rsync n'est pas une option.

Quelqu'un peut-il me recommander un outil de copie de fichiers simple qui peut mettre en file d'attente les fichiers à copier / déplacer / supprimer? De préférence si je peux glisser-déposer depuis Nautilus.

Si quelque chose comme ça n'existe pas, quelqu'un peut-il me dire pourquoi? ... suis-je la seule personne qui a besoin de quelque chose comme ça?

Je viens d'écrire ce script simple, que j'ai appelé «cpw», pour résoudre ce problème.

Vous l'utilisez comme vous utiliseriez cp ... la seule différence est qu'il construit un tableau de tous les processus cpw qui sont déjà en cours d'exécution au démarrage et attend qu'ils se terminent avant de passer les commandes à cp. De cette façon, il se comporte comme une file d'attente auto-organisée.

Vous pouvez continuer à ajouter des tâches cpw en arrière-plan, mais elles ne marcheront pas les unes sur les autres. Ils exécuteront un à la fois.

Je suis sûr que d'autres peuvent suggérer des améliorations.

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

Exemple d'utilisation:

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

D'après mon expérience, faire quelques copies simultanément sous Linux ne réduit pas vraiment le débit global. Ma mesure du débit est basée sur l'argument -P de rsync. Mon cas particulier consiste à copier séparément un certain nombre de dossiers remplis de gros fichiers hors d'un disque dur USB en même temps.

Donc, à moins que vous ne copiiez beaucoup de choses à la fois, ça devrait aller.

Étant donné que le script donné par Josh Arenberg pourrait avoir des problèmes de blocage (que je n'ai pas rencontrés jusqu'à présent, mais que je n'ai pas non plus étudiés), j'ai écrit quelque chose par moi-même. Il ne devrait pas avoir de problèmes de blocage. Il fonctionne également pour n'importe quelle commande shell, pas seulement pour 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

Il crée une chaîne de processus, chacun attendant le précédent. Si un processus au milieu de la chaîne se bloque en attente (peu probable mais pas impossible), la chaîne est cassée et les deux parties fonctionnent en parallèle. La même chose se produit si l'un des processus est tué.

Utilisation comme ceci:

q $COMMAND $ARGS

ou même

q $COMMAND $ARGS; $ANOTHER_COMMAND $MORE_ARGS

Testez par exemple en tapant

q sleep 10 &
q echo blubb &

et constater qu'au bout de 10 secondes, blubb est imprimé.

Ultracopier est celui que vous voulez, avec le plugin Nemo ou le plugin Nautilus .

Je ne connais rien de tel pour Linux (mais cela ne veut pas dire qu'il n'y en a pas quelque part). Les logiciels Linux ont tendance à être écrits par les utilisateurs Linux. Les utilisateurs Linux expérimentés peuvent ne pas penser à créer un outil comme celui-ci, car s'ils remarquent un ralentissement des copies pendant une session GUI, ils sont susceptibles de basculer vers un terminal et de copier via la ligne de commande.

Voici quelques utilitaires de copie de ligne de commande très rapides et qui ne devraient pas affecter votre environnement de bureau:

• cp ("cp foo / path / to / bar" copiera foo sur bar)
• mv ("mv foo / path / to / bar" déplacera (renommera) foo en bar)
• tar ("tar cf - foo | (cd / chemin / vers / archive /; tar xf -)" copiera récursivement un répertoire)
• rsync ("rsync -r foo / path / to / archive /" copiera récursivement un répertoire)

Créez une liste de fichiers et utilisez SCP pour effectuer la copie. La bonne chose sous Linux est que vous pouvez ajouter à votre fichier texte en utilisant echo.

J'ai trouvé ce projet Unix Batch System appelé Task Spooler qui vous permet de mettre les tâches en file d'attente.

• Arch linux
• Ubuntu

Ou vous pouvez faire sudo apt-get install task-spooler

Une fois installé, vous pouvez simplement placer ts(ou tsppour les systèmes Ubuntu / Debian) devant n'importe quelle commande shell standard pour la mettre en file d'attente.

Cette page contient de nombreux exemples sur ses utilisations: https://www.ostechnix.com/add-linux-commands-queue-execute-one-one/ ou vous regardez une vidéo ici: https://www.youtube.com / watch? v = wv8D8wT20ZY

Je l'ai vérifié et il semble fonctionner comme prévu pour toutes mes cpcommandes.