Início / unix / Perguntas / 410649
Accepted
Tomilov Anatoliy
Asked: 2017-12-14 06:10:27 +0800 CST

diretório tar para enviar apenas blocos modificados de arquivos

  • 772

A estrutura de diretório profunda e complexa pode ser modificada: os arquivos podem ser movidos (o prefixo alterado) e simultaneamente o conteúdo dos arquivos pode ser alterado parcialmente.

Eu quero diminuir uma quantidade de dados para transmitir pela rede.

rsynctrabalha com blocos de dados de tamanho 4k (se bem me lembro).

Posso usar algum tipo de concatenação ( tar-like) preservando metainformações sobre a estrutura e os atributos do sistema de arquivos, que coloca o conteúdo do arquivo a partir de deslocamentos de vários bytes de 4k para cada próximo arquivo para habilitar as rsyncvantagens do algoritmo?

O problema que desejo resolver é a omissão de rsync: ele não consegue detectar se o conteúdo do arquivo foi alterado e o arquivo é movido ao mesmo tempo entre as sincronizações para usar blocos correspondentes de arquivos de destino para reduzir a transferência de dados.

rsync tar

3 respostas

  1. Best Answer

    Com base na sua sugestão em um comentário (que realmente deveria estar na sua pergunta), parece ser isso que você deseja

    cd /path/to/directory
tar cf /var/tmp/directory.tar .
rsync -azv /var/tmp/directory.tar remote:/var/tmp/directory.tar
ssh remote 'cd /path/to/destination && tar xf /var/tmp/directory.tar'

    Você precisa de espaço suficiente para armazenar directory.tarem ambos os lados.

    Me perguntaram se essa solução aparentemente trivial pode funcionar na situação em que uma pequena quantidade, como um único byte, é adicionada (ou removida) do início do arquivo tar.

    Espero que este exemplo ilustre como rsyncé bom lidar com essas situações. Funciona melhor se você tiver um login de equivalência (chave de certificado) para o servidor remoto, para que nenhum tempo seja gasto digitando uma senha.

    # Generate some data
dd iflag=fullblock bs=1M count=200 </dev/urandom >200M.dat

# See how long it takes to transfer
time rsync -av 200M.dat remote:

# See how long it takes to transfer "nothing"
time rsync -av 200M.dat remote:

# Generate one byte of data and prepend it to another data file
dd bs=1 count=1 </dev/urandom >1b.dat
cat 1b.dat 200M.dat >200M1b.dat

# Copy the new file across to the original target
time rsync -av 200M1b.dat remote:200M.dat

# Clean up
rm 1b.dat 200M.dat 200M1b.dat
ssh remote rm 200M.dat

    Se o algoritmo puder lidar com o único byte inserido no início do fluxo de dados, a transferência deve demorar apenas alguns instantes. Se não puder, você esperaria que o tempo de transferência fosse amplamente semelhante ao primeiro.

    • 2

  2. Aqui vai mais uma sugestão para você. A hrsyncferramenta , que encontrei no GitHub, parece ser muito boa em manter uma memória de arquivos quando você os renomeia ou os move entre os diretórios de uma árvore de origem.

    • Ele pode rastrear movimentos e edições em arquivos dentro da árvore de origem
    • É um script de shell e não requer privilégios administrativos para instalar no sistema de origem, embora colocá-lo /usr/local/bintenha vantagens
    • Requer que os sistemas locais e remotos tenham um sistema de arquivos capaz de lidar com hard links
    • Não é possível rastrear alterações em um arquivo em que esse arquivo é renomeado e substituído (ou seja, excluído e recriado, em vez de editado no local)

    Exemplo

    hrsync /path/to/directory/ remote:/path/to/destination/
    • 1

  3. Encontrei a solução usando bashapenas utilitários de linha de comando. É possível otimizar a solução: classificar os arquivos por tamanho em ordem crescente e colocar o máximo possível de arquivos pequenos em cada bloco (problema de mochila aqui =), mas seria engenharia excessiva):

    pack.bash:

    #! /usr/bin/env bash

set -e

[[ -d "$1" ]]
[[ -d "$( dirname '$2' )" ]]

BLOB="$2.blob"
FSIZES="$2.sizes"
OFFSET=0

shopt -s globstar
for f in "$1"/* "$1"/**/*
do
    if [[ -f "$f" ]]
    then
        SIZE=$( stat -c %s "$f" )
        echo "$SIZE" >> "$FSIZES"
        COUNT=$(( ($SIZE + 4096 - 1) / 4096 ))
        dd if="$f" of="$BLOB" bs=4096 seek=$OFFSET count=$COUNT conv=notrunc
        OFFSET=$(( $COUNT + $OFFSET ))
    fi
done

cp --recursive --archive --attributes-only "$1" "$2.dir"
XZ_OPT="-9e --threads=$(( $( nproc ) + 1 ))" tar cpJf "$2.tar.xz" -C "$2.dir" .
rm --recursive "$2.dir"

    unpack.bash:

    #! /usr/bin/env bash

set -e

BLOB="$2.blob"
FSIZES="$2.sizes"

[[ -f "$BLOB" ]]
[[ -f "$FSIZES" ]]

mkdir --parents "$1"
[[ ! "$( ls -A '$1' )" ]]

tar xpJf "$2.tar.xz" -C "$1"

SIZES=($( < "$FSIZES" ))

i=0
OFFSET=0
shopt -s globstar
for f in "$1"/* "$1"/**/*
do
    if [[ -f "$f" ]]
    then
        SIZE=${SIZES[i]}
        dd if="$BLOB" of="$f" bs=4096 skip=$OFFSET count=$SIZE iflag=count_bytes
        OFFSET=$(( $OFFSET + ($SIZE + 4096 - 1) / 4096 ))
        i=$(( $i + 1 ))
    fi
done
    • 0

relate perguntas