Convertir tar.gz zip

J'ai une grande collection d'archives au format gzip sur mon Ubuntu serveur, et j'ai besoin de les convertir à zip. Je me figure que ce serait fait avec un script, mais dans quelle langue dois-je utiliser, et comment pourrais-je aller sur la décompression et rezipping fichiers?

OriginalL'auteur Dan | 2011-06-10

6

Je le ferais avec un bash(1) one-liner:
```
for f in *.tar.gz;\
do rm -rf ${f%.tar.gz} ;\
mkdir ${f%.tar.gz} ;\
tar -C ${f%.tar.gz} zxvf $f ;\
zip -r ${f%.tar.gz} $f.zip ;\
rm -rf ${f%.tar.gz} ;\
done
```
Il n'est pas très beau, parce que je ne suis pas très à bash(1). Notez que ce qui détruit beaucoup de répertoires, afin d'être sûr que vous savez ce que cela fait, avant de le faire.

Voir le bash(1) de la carte de référence pour plus de détails sur la ${foo%bar} syntaxe.

C'est en gros ce que je suggère, mais vous avez été plus rapide à concocter un exemple que moi. 🙂
pas la peine de test est un bon moyen pour se raser les minutes. 🙂

OriginalL'auteur sarnold
2

Un simple script bash serait plus facile, sûrement? De cette façon, vous pouvez simplement appeler la tar et zip commandes.

OriginalL'auteur Sven
1

la solution la plus simple sur les plates-formes unix peut-être bien d'utiliser un fusible et quelque chose comme archivemount (libarchive), http://en.wikipedia.org/wiki/Archivemount .

/iaw

OriginalL'auteur ivo Welch

Vous pouvez utiliser node.js et tar-à-zip à cette fin. Tout ce que vous devez faire est de:

Installer node.js avec nvm si vous ne l'avez pas.

Et ensuite installer tar-to-zip avec:

npm i tar-to-zip -g

Et l'utiliser avec:

tarzip *.tar.gz

Aussi, vous pouvez convertir .tar.gz fichiers .zip par programmation.
Vous devez installer async et tar-to-zip localement:

npm i async tar-to-zip

Et puis créer converter.js avec le contenu:

#!/usr/bin/env node

'use strict';

const fs = require('fs');
const tarToZip = require('tar-to-zip');
const eachSeries = require('async/eachSeries');
const names = process.argv.slice(2);

eachSeries(names, convert, exitIfError);

function convert(name, done) {
    const {stdout} = process;
    const onProgress = (n) => {
        stdout.write(`\r${n}%: ${name}`);
    };
    const onFinish = (e) => {
        stdout.write('\n');
        done();
    };

    const nameZip = name.replace(/\.tar\.gz$/, '.zip');    
    const zip = fs.createWriteStream(nameZip)
        .on('error', (error) => {
            exitIfError(error);
            fs.unlinkSync(zipPath);
        });

    const progress = true;
    tarToZip(name, {progress})
        .on('progress', onProgress)
        .on('error', exitIfError)
        .getStream()
        .pipe(zip)
        .on('finish', onFinish);
}

function exitIfError(error) {
    if (!error)
        return;

    console.error(error.message);
    process.exit(1);
}

OriginalL'auteur coderaiser

Zipfiles sont pratiques, car ils offrent un accès aléatoire aux fichiers. Tar uniquement les fichiers séquentiels.

Ma solution pour cette conversion est ce script shell qui appelle elle-même via tar(1) "à la commande" option. (Je préfère ça plutôt que d'avoir 2 scripts). Mais j'avoue que "décompresser et zip-r" est plus rapide que cela, car zipnote(1) ne peut pas travailler sur place, malheureusement.

#!/bin/zsh -feu

## Convert a tar file into zip:

usage() {
    setopt POSIX_ARGZERO
    cat <<EOF
    usage: ${0##*/} [+-h] [-v] [--] {tarfile} {zipfile}"

-v verbose
-h print this message
converts the TAR archive into ZIP archive.
EOF
    unsetopt POSIX_ARGZERO
}

while getopts :hv OPT; do
    case $OPT in
        h|+h)
            usage
            exit
            ;;
        v)
            # todo: ignore TAR_VERBOSE from env?
            # Pass to the grand-child process:
            export TAR_VERBOSE=y
            ;;
        *)
            usage >&2
            exit 2
    esac
done
shift OPTIND-1
OPTIND=1

# when invoked w/o parameters:
if [ $# = 0 ] # todo: or stdin is not terminal
then
    # we are invoked by tar(1)
    if [ -n "${TAR_VERBOSE- }" ]; then echo $TAR_REALNAME >&2;fi
    zip --grow --quiet $ZIPFILE -
    # And rename it:
    # fixme: this still makes a full copy, so slow.
    printf "@ -\n@=$TAR_REALNAME\n" | zipnote -w $ZIPFILE
else
    if [ $# != 2 ]; then usage >&2; exit 1;fi
    # possibly: rm -f $ZIPFILE
    ZIPFILE=$2 tar -xaf $1 --to-command=$0
fi

OriginalL'auteur mmaruska

Ici est un python solution basée sur ce réponse ici:

import sys, tarfile, zipfile, glob

def convert_one_archive(file_name):
    out_file = file_name.replace('.tar.gz', '.zip')
    with tarfile.open(file_name, mode='r:gz') as tf:
        with zipfile.ZipFile(out_file, mode='a', compression=zipfile.ZIP_DEFLATED) as zf:
            for m in tf.getmembers():
                f = tf.extractfile( m )
                fl = f.read()
                fn = m.name
                zf.writestr(fn, fl)

for f in glob.glob('*.tar.gz'):
    convert_one_archive(f)

OriginalL'auteur Brad Campbell

Vous devez vous connecter pour publier un commentaire.