linux - Cómo comparar el contenido de dos tarball

compare compression

Question

Quiero saber si dos archivos de tarball contienen archivos idénticos, en términos de nombre de archivo y contenido de archivo, sin incluir metadatos como fecha, usuario, grupo.

Sin embargo, existen algunas restricciones: primero, no tengo control sobre si se incluyen los metadatos cuando se crea el archivo tar, en realidad, el archivo tar siempre contiene metadatos, por lo tanto, la diferencia directa entre los dos archivos tar no funciona. En segundo lugar, dado que algunos archivos tar son tan grandes que no puedo permitirme descomprimirlos en un directorio temporal y diferenciar los archivos contenidos uno por uno. (Sé que si puedo untar file1.tar en file1 /, puedo compararlos invocando ''tar -dvf file2.tar'' en el archivo /. Pero normalmente no puedo permitirme untar incluso uno de ellos)

¿Alguna idea de cómo puedo comparar los dos archivos tar? Sería mejor si se puede lograr dentro de los scripts de SHELL. Alternativamente, ¿hay alguna forma de obtener la suma de comprobación de cada subarchivo sin descomprimir un archivo?

Gracias,

Answer 1

¿Es tardiff lo que estás buscando? Es "un simple script de Perl" que "compara el contenido de dos archivos comprimidos e informa sobre cualquier diferencia encontrada entre ellos".

Answer 2

¿Estás controlando la creación de estos archivos tar?
Si es así, el mejor truco sería crear una suma de comprobación MD5 y almacenarla en un archivo dentro del propio archivo. Luego, cuando desee comparar dos archivos, simplemente extraiga estos archivos de suma de comprobación y compárelos.

Si puede permitirse extraer solo un archivo tar , puede usar la opción --diff de tar para buscar diferencias con el contenido de otro archivo tar.

Un truco más crudo si está bien con solo una comparación de los nombres de archivo y sus tamaños .
¡Recuerda, esto no garantiza que los otros archivos sean iguales!

ejecute un tar tvf para listar el contenido de cada archivo y almacenar las salidas en dos archivos diferentes. luego, corte todo, además de las columnas de nombre de archivo y tamaño. Preferiblemente ordene los dos archivos también. Luego, simplemente haga un archivo de diferencia entre las dos listas.

Solo recuerda que este último esquema no hace realmente suma de comprobación.

Muestra de tar y salida (todos los archivos son de tamaño cero en este ejemplo).

$ tar tvfj pack1.tar.bz2
drwxr-xr-x user/group 0 2009-06-23 10:29:51 dir1/
-rw-r--r-- user/group 0 2009-06-23 10:29:50 dir1/file1
-rw-r--r-- user/group 0 2009-06-23 10:29:51 dir1/file2
drwxr-xr-x user/group 0 2009-06-23 10:29:59 dir2/
-rw-r--r-- user/group 0 2009-06-23 10:29:57 dir2/file1
-rw-r--r-- user/group 0 2009-06-23 10:29:59 dir2/file3
drwxr-xr-x user/group 0 2009-06-23 10:29:45 dir3/

Comando para generar lista ordenada de nombre / tamaño

$ tar tvfj pack1.tar.bz2 | awk ''{printf "%10s %s/n",$3,$6}'' | sort -k 2
0 dir1/
0 dir1/file1
0 dir1/file2
0 dir2/
0 dir2/file1
0 dir2/file3
0 dir3/

Puedes tomar dos de estas listas ordenadas y diferenciarlas.
También puede usar las columnas de fecha y hora si eso funciona para usted.

Answer 3

Aquí está mi variante, está comprobando el permiso de Unix también:

Funciona solo si los nombres de los archivos tienen menos de 200 caracteres.

diff <(tar -tvf 1.tar | awk ''{printf "%10s %200s %10s/n",$3,$6,$1}''|sort -k2) <(tar -tvf 2.tar|awk ''{printf "%10s %200s %10s/n",$3,$6,$1}''|sort -k2)

Answer 4

Hay una herramienta llamada archdiff . Es básicamente un script de perl que puede mirar en los archivos.

Takes two archives, or an archive and a directory and shows a summary of the
differences between them.

Answer 5

Intente también pkgdiff para visualizar las diferencias entre paquetes (detecta los archivos agregados / eliminados / renombrados y el contenido modificado, existe con código cero si no se modifica):

pkgdiff PKG-0.tgz PKG-1.tgz

Answer 6

Me doy cuenta de que esta es una respuesta tardía, pero encontré el hilo mientras intentaba lograr lo mismo. La solución que he implementado genera la salida de tar a stdout y la canaliza a cualquier hash que elija:

tar -xOzf archive.tar.gz | sort | sha1sum

Tenga en cuenta que el orden de los argumentos es importante; particularmente O qué señales utilizar stdout.

Answer 7

Si no extrae los archivos ni necesita las diferencias, pruebe la opción -q de diff :

diff -q 1.tar 2.tar

Este resultado silencioso será "1.tar 2.tar diferir" o nada, si no hay diferencias.

Answer 8

Tengo una pregunta similar y la resuelvo mediante Python, aquí está el código. ps: aunque este código se usa para comparar el contenido de dos zipball, pero es similar con tarball, espero poder ayudarte

import zipfile
import os,md5
import hashlib
import shutil

def decompressZip(zipName, dirName):
    try:
        zipFile = zipfile.ZipFile(zipName, "r")
        fileNames = zipFile.namelist()
        for file in fileNames:
            zipFile.extract(file, dirName)
        zipFile.close()
        return fileNames
    except Exception,e:
        raise Exception,e

def md5sum(filename):
    f = open(filename,"rb")
    md5obj = hashlib.md5()
    md5obj.update(f.read())
    hash = md5obj.hexdigest()
    f.close()
    return str(hash).upper()

if __name__ == "__main__":
    oldFileList = decompressZip("./old.zip", "./oldDir")
    newFileList = decompressZip("./new.zip", "./newDir")

    oldDict = dict()
    newDict = dict()

    for oldFile in oldFileList:
        tmpOldFile = "./oldDir/" + oldFile
        if not os.path.isdir(tmpOldFile):
            oldFileMD5 = md5sum(tmpOldFile)
            oldDict[oldFile] = oldFileMD5

    for newFile in newFileList:
        tmpNewFile = "./newDir/" + newFile
        if not os.path.isdir(tmpNewFile):
            newFileMD5 = md5sum(tmpNewFile)
            newDict[newFile] = newFileMD5

    additionList = list()
    modifyList = list()

    for key in newDict:
        if not oldDict.has_key(key):
            additionList.append(key)
        else:
            newMD5 = newDict[key]
            oldMD5 = oldDict[key]
            if not newMD5 == oldMD5:
            modifyList.append(key)

    print "new file lis:%s" % additionList
    print "modified file list:%s" % modifyList

    shutil.rmtree("./oldDir")
    shutil.rmtree("./newDir")

Answer 9

Uno puede usar un script simple:

#!/usr/bin/env bash
set -eu

tar1=$1
tar2=$2
shift 2
tar_opts=("$@")

tmp1=`mktemp -d`
_trap="rm -r "$tmp1"; ${_trap:-}" && trap "$_trap" EXIT
tar xf "$tar1" -C "$tmp1"

tmp2=`mktemp -d`
_trap="rm -r "$tmp2"; ${_trap:-}" && trap "$_trap" EXIT
tar xf "$tar2" -C "$tmp2"

diff -ur "${tar_opts[@]:+${tar_opts[@]}}" "$tmp1" "$tmp2"

Uso:

diff-tars.sh TAR1 TAR2 [DIFF_OPTS]

Answer 10

tarsum es casi lo que necesitas. Tome su salida, ejecútelo para obtener el orden idéntico en cada uno, y luego compare los dos con diff. Eso debería hacer que una implementación básica funcione, y sería lo suficientemente fácil llevar esos pasos al programa principal modificando el código de Python para hacer todo el trabajo.