Programar arquivos de fila para copiar / mover / excluir no linux?

Pesquisei na net a resposta do Linux para algo como Teracopy (Windows) ... mas não consegui encontrar nada adequado.

As coisas mais próximas que cheguei são:

• Krusader. Mencionado em seus recursos, mas indicado como 'ainda não implementado'.
• MiniCopier. Um aplicativo baseado em java http://a.courreges.free.fr/projets/minicopier/minicopier-en.php
• rsync não é uma opção.

Alguém pode me recomendar uma ferramenta simples de cópia de arquivo que possa enfileirar arquivos para copiar / mover / excluir? De preferência, se eu puder arrastar e soltar do Nautilus.

Se algo assim não existir, alguém pode me dizer por quê? ... eu sou a única pessoa que precisa de algo assim?

Acabei de escrever este script simples, que chamei de 'cpw', para resolver esse problema.

Você o usa exatamente como usaria o cp ... a única diferença é que ele cria uma matriz de todos os processos cpw que já estão em execução quando é iniciado e espera que eles terminem antes de passar os comandos para o cp. Dessa maneira, ele se comporta como uma fila auto-organizada.

Você pode continuar adicionando trabalhos cpw em segundo plano, mas eles não se interpõem. Eles executam um de cada vez.

Tenho certeza que outros podem sugerir melhorias.

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

Exemplo de uso:

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

Na minha experiência, fazer algumas cópias simultaneamente no Linux realmente não reduz a taxa de transferência geral. Minha medição da taxa de transferência é baseada no argumento -P do rsync. Meu caso particular é copiar separadamente várias pastas cheias de arquivos grandes de um disco rígido USB ao mesmo tempo.

Portanto, a menos que você esteja copiando muitas coisas ao mesmo tempo, você deve ficar bem.

Como o script fornecido por Josh Arenberg pode ter alguns problemas de impasse (que eu não experimentei até agora, mas também não investiguei), escrevi algo sozinho. Não deve ter problemas de conflito. Também funciona para qualquer comando shell, não apenas para o 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

Ele cria uma cadeia de processos, cada um aguardando o anterior. Se um processo no meio da cadeia travar enquanto aguarda (improvável, mas não impossível), a corrente é interrompida e as duas partes são executadas em paralelo. O mesmo acontece se um dos processos for morto.

Uso como este:

q $COMMAND $ARGS

ou mesmo

q $COMMAND $ARGS; $ANOTHER_COMMAND $MORE_ARGS

Teste, por exemplo, digitando

q sleep 10 &
q echo blubb &

e descobrindo que após 10 segundos o blubb é impresso.

Ultracopier é um que você quiser, com Nemo plug-in ou Nautilus plug-in .

Não conheço nada parecido com o Linux (embora isso não signifique que não exista um em algum lugar). O software Linux tende a ser escrito pelos usuários do Linux. Os usuários experientes do Linux podem não pensar em criar uma ferramenta como essa, porque se perceberem alguma lentidão nas cópias durante uma sessão da GUI, provavelmente mudarão para um terminal e copiarão via linha de comando.

Aqui estão alguns utilitários básicos de cópia de linha de comando que são muito rápidos e não devem afetar o ambiente da área de trabalho:

• cp ("cp foo / path / to / bar" copia foo para bar)
• mv ("mv foo / path / to / bar" será movido (renomeado) foo para bar)
• tar ("tar cf - foo | (cd / caminho / para / archive /; tar xf -)" copiará recursivamente um diretório)
• rsync ("rsync -r foo / path / to / archive /" copia recursivamente um diretório)

Crie uma lista de arquivos e use o SCP para executar a cópia. O legal do linux é que você pode adicionar ao seu arquivo de texto usando o echo.

Eu encontrei este projeto do Unix Batch System chamado Task Spooler, que permite enfileirar tarefas.

• Arch linux
• Ubuntu

Ou você pode fazer sudo apt-get install task-spooler

Uma vez instalado, você pode simplesmente colocar ts(ou tsppara sistemas Ubuntu / Debian) na frente de qualquer comando shell comum para colocá-lo na fila.

Esta página possui muitos exemplos de uso: https://www.ostechnix.com/add-linux-commands-queue-execute-one-one/ ou você assiste a um vídeo aqui: https://www.youtube.com / watch? v = wv8D8wT20ZY

Eu verifiquei e parece estar funcionando como esperado para todos os meus cpcomandos.