[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]

Capitolo 74. Archiviazione e compressione

L'archiviazione e la compressione sono le fasi attraverso le quali si realizzano delle copie di sicurezza, oppure si preparano i dati prima di una trasmissione. La tabella 74.1 elenca i programmi a cui si accenna in questo capitolo.

Tabella 74.1. Riepilogo dei programmi per l'archiviazione e la compressione di file e directory.

Programma	Descrizione
cpio	Archivia e recupera.
tar	Archivia e recupera.
gzip	Comprime e decomprime.
bzip2	Comprime e decomprime.

74.1 Archiviazione

L'archiviazione è quel procedimento con cui si impacchettano file o rami di directory in modo da facilitarne la conservazione all'interno di unità di memorizzazione senza file system. Per lo stesso motivo, l'archiviazione è il modo con cui si possono trasferire agevolmente i dati attraverso piattaforme differenti.

L'archiviazione pura e semplice non ottiene alcun risparmio nello spazio utilizzato dai dati. Per questo si utilizza la compressione che permette di ridurre questo utilizzo.

L'archiviazione pura e semplice è ottenuta normalmente attraverso il programma tar o il programma cpio. Questi due sono equivalenti, almeno a livello teorico. In pratica, è l'utilizzatore che sceglie quello che per qualche motivo gli è più simpatico, specializzandosi nell'uso delle sue opzioni particolari.

Questo argomento viene ripreso anche nel capitolo dedicato alle copie di sicurezza (351).

74.1.1 $ cpio

cpio -o [opzioni] [< elenco_nomi] [> archivio]

cpio -i [opzioni] [modello] [< archivio]

cpio -p [opzioni] directory_di_destinazione [< elenco_nomi]

Copia file da e verso archivi cpio o tar. ⁽¹⁾ L'archivio può essere un file su disco, un nastro magnetico o una pipe. Le tre sintassi indicate rappresentano le tre modalità operative del comando.

copy-out (archiviazione)

Dallo standard input viene letto un elenco di nomi di file (uno per riga) e l'archivio di questi file viene generato ed emesso attraverso lo standard output.
copy-in (lettura di un archivio)

Dallo standard input viene letto il contenuto di un archivio dal quale si possono estrarre i file in esso contenuti.
copy-pass (copia)

Dallo standard input viene letto un elenco di nomi di file (uno per riga) e questi file (con il loro contenuto) vengono copiati nella directory di destinazione.

Vedere cpio.info o cpio(1).

Alcune opzioni per il copy-out

-o | --create

Funziona in modalità copy-out.

-A | --append

Aggiunge dati a un archivio esistente che deve essere specificato con l'opzione -O.

-L | --dereference

Quando incontra dei collegamenti simbolici, copia i file a cui questi puntano, invece di copiare semplicemente i collegamenti.

-O nome_archivio

Specifica il nome dell'archivio da creare o incrementare, invece di utilizzare lo standard output.

Alcune opzioni per il copy-in

-i | --extract

Funziona in modalità copy-in.

-d | --make-directories

Crea le directory necessarie.

-E file | --pattern-file=file

Legge il modello che esprime i nomi dei file da estrarre, o l'elenco dei nomi stessi, dal file indicato come argomento dell'opzione.

-f | --nomatching

Copia soltanto i file che non corrispondono al modello indicato.

-I archivio

Permette di specificare il nome dell'archivio da usare, invece di riceverlo dallo standard input.

-t | --list

Elenca il contenuto dell'archivio.

Alcune opzioni per il copy-pass

-p | --pass-through

Funziona in modalità copy-pass.

-d | --make-directories

Crea le directory necessarie.

-l | --link

Se possibile, crea dei collegamenti invece di copiare i file.

-L | --dereference

Quando incontra dei collegamenti simbolici, copia i file a cui questi puntano, invece di copiare semplicemente i collegamenti.

Esempi

$ cpio -o < elenco > /tmp/archivio.cpio

Archivia i file e le directory elencati nel file elenco generando il file /tmp/archivio.cpio.

$ ls *.sgml | cpio -o > /tmp/archivio.cpio

Archivia i file e le directory corrispondenti al modello *.sgml generando il file /tmp/archivio.cpio.

$ find lavoro -print | cpio -o > /tmp/archivio.cpio

Archivia la directory lavoro/ e tutto il suo contenuto, generando il file /tmp/archivio.cpio.

$ cpio -i -t < /tmp/archivio.cpio

Elenca il contenuto dell'archivio /tmp/archivio.cpio.

$ cpio -i < /tmp/archivio.cpio

estrae l'archivio /tmp/archivio.cpio a partire dalla directory corrente.

$ cpio -p < elenco > /tmp/prova

Copia i file e le directory elencati nel file elenco nella directory /tmp/prova/.

74.1.2 $ tar

tar opzione_di_funzionamento [opzioni] file...

tar ⁽²⁾ (Tape archive) è un programma di archiviazione nato originariamente per essere usato con i nastri. Il primo argomento deve essere una delle opzioni che ne definisce il funzionamento. Alla fine della riga di comando vengono indicati i nomi dei file o delle directory da archiviare. Se non viene specificato diversamente con le opzioni, l'archivio viene emesso attraverso lo standard output.

Il tar tradizionale ammette l'uso di opzioni senza il trattino anteriore (-) consueto. Questa tradizione è stata mantenuta anche nel tar GNU a cui si vuole fare riferimento qui, ma tale forma deve essere usata consapevolmente e con prudenza. Negli esempi verrà mostrato in che modo potrebbero essere usate tali opzioni senza trattino.

Per la descrizione completa di questo programma, conviene consultare tar(1).

Opzioni di funzionamento

Un gruppo di opzioni rappresenta l'operazione da compiere. Di queste, può e deve esserne utilizzata una sola. Di solito, data la loro importanza, queste opzioni appaiono all'inizio degli argomenti di tar.

A | -A | --catenate | --concatenate

Aggiunge dei file tar a un archivio già esistente.

c | -c | --create

Crea un nuovo archivio.

d | -d | --diff | --compare

Trova le differenze tra l'archivio e i file esistenti effettivamente.

--delete

Cancella dall'archivio i file indicati. Non può essere usato per un archivio su nastro.

r | -r | --append

Aggiunge dati a un archivio già esistente.

t | -t | --list

Elenca il contenuto di un archivio.

u | -u | --update

Aggiunge solo i file più recenti rispetto a quanto già contenuto nell'archivio.

x | -x | --extract | --get

Estrae i file da un archivio.

altre opzioni

--atime-preserve

Fa in modo che la data di accesso dei file che vengono archiviati non venga modificata.

-f file | --file=file

Emette l'archivio nel file o nel dispositivo. Se si tratta di un file normale, questo viene creato.

-h | --dereference

Non copia i collegamenti simbolici, ma i file a cui questi fanno riferimento.

-k | --keep-old-files

In fase di estrazione da un archivio, non sovrascrive i file eventualmente già esistenti.

-l | --one-file-system

Quando viene creato un archivio, resta in un solo file system: quello di partenza.

-L Kibyte | --tape-length=Kibyte

Definisce la dimensione massima dei vari segmenti di copia multivolume.

-m | --modification-time

In fase di estrazione da un archivio, non viene ripristinata la data di modifica dei file.

-M | --multi-volume

Permette di creare, elencare o estrarre, un archivio multivolume.

-N data | --after-date=data | --newer data

Archivia solo i file la cui data è più recente di quella indicata come argomento.

-O | --to-stdout

Estrae i file emettendoli attraverso lo standard output.

-p | --same-permissions | --preserve-permissions

Estrae tutti i permessi associati ai file. Se non viene usata questa opzione, i file ottengono i permessi predefiniti, anche in funzione della maschera dei permessi dell'utente che esegue l'operazione.

-P | --absolute-path

Estrae i file utilizzando i percorsi assoluti, cioè senza eliminare la prima barra (/) che appare nei nomi di percorso (pathname).

--remove-files

In fase di creazione di un nuovo archivio, elimina i file archiviati.

--same-owner

Durante l'estrazione da un archivio, assegna ai file estratti gli utenti e i gruppi proprietari originali.

-v | --verbose

Elenca i file che vengono elaborati.

-W | --verify

Cerca di verificare la validità dell'archivio dopo averlo creato.

-Z | --compress | --uncompress

Filtra l'archivio attraverso il programma di compressione compress.

-z | --gzip | --ungzip

Filtra l'archivio attraverso il programma di compressione gzip.

-j | --bzip2

Filtra l'archivio attraverso il programma di compressione bzip2 (sia per la compressione che per l'estrazione).

--use-compress-program programma

Filtra l'archivio attraverso il programma di compressione indicato nell'argomento. Questo programma di compressione deve riconoscere l'opzione -d, come fa gzip, allo scopo di decomprimere i dati.

Esempi

# tar -c -f /dev/fd0 -L 1440 -M -v /usr

Archivia la directory /usr/ con tutto il suo contenuto, comprese le sottodirectory, utilizzando i dischetti (da 1 440 Kibyte).

Con la copia multivolume, come in questo caso, non è possibile utilizzare la compressione automatica attraverso l'opzione -z o -Z.

# tar cf /dev/fd0 -L 1440 -M -v /usr

Esattamente come nell'esempio precedente, con la differenza che le opzioni -c e -f sono indicate senza il trattino iniziale.

# tar cvf /dev/fd0 -L 1440 -M /usr

Esattamente come nell'esempio precedente.

# tar -cfv /dev/fd0 -L 1440 -M /usr

# tar cfv /dev/fd0 -L 1440 -M /usr

Questi due esempi sono identici ed errati ugualmente. Non è possibile accodare lettere di altre opzioni dopo la «f», dal momento che questa richiede un argomento.

In molti documenti su tar si vedono esempi errati di questo tipo. Possono anche funzionare, ma sono errati concettualmente ed è molto probabile incontrare un programma tar che in tali situazioni faccia qualcosa di diverso da quello che ci si aspetterebbe.

$ tar -t -f /dev/fd0 -L 1440 -M -v

Visualizza l'elenco del contenuto dell'archivio fatto su dischetti.

$ tar -x -f /dev/fd0 -L 1440 -M -v -p --same-owner

Estrae il contenuto dell'archivio su dischetti a partire dalla posizione corrente.

È probabile che l'opzione --same-owner sia già predefinita all'interno di tar, ma in generale vale la pena di ricordarsene. Tuttavia, in questi esempi, dal momento che si tratta di un utente comune (lo si vede dal dollaro che viene indicato come invito), non ha significato, dal momento che l'utente comune non ha la possibilità di assegnare a un altro la proprietà dei file che crea.

$ tar xpvf /dev/fd0 -L 1440 -M --same-owner

Come nell'esempio precedente, aggregando alcune opzioni e togliendo il trattino iniziale di queste.

$ tar -c -f /tmp/archivio.tgz -z -v /usr

Archivia il contenuto della directory /usr/ nel file /tmp/archivio.tgz dopo averlo compresso con gzip.

$ tar czvf /tmp/archivio.tgz /usr

Come nell'esempio precedente.

74.2 Compressione

La compressione dei dati è una tecnica che consente di risparmiare senza perdere informazioni. L'operazione avviene di norma in modo sequenziale, per cui può essere gestita attraverso dei programmi filtro, che alle volte permettono di rendere trasparente l'operazione. Data la facilità con cui nei sistemi Unix si possono combinare assieme delle tecniche di questo genere, in tali ambienti si tende a preferire l'archiviazione seguita da una compressione complessiva.

74.2.1 $ gzip, gunzip, zcat

gzip [opzioni] [file...]

gunzip [opzioni] [file...]

zcat [opzioni] [file...]

gzip ⁽³⁾ è un programma di compressione attraverso il quale viene creato un file compresso per ogni file indicato negli argomenti. gzip è in grado di comprimere solo file normali, in modo singolo: per ogni file ne viene generato un altro con l'estensione .gz o un'altra se specificato diversamente con le opzioni. Se non viene indicato alcun file o se si utilizza espressamente un trattino isolato (-), lo standard input viene compresso e il risultato viene emesso attraverso lo standard output.

gunzip è un collegamento a gzip. Se gzip viene avviato con il nome gunzip si comporta come se fosse stata utilizzata l'opzione -d.

zcat è un collegamento a gzip. Se gzip viene avviato con il nome zcat si comporta come se fossero state utilizzate simultaneamente le opzioni -d e -c. In alcuni sistemi, invece di zcat potrebbe essere presente il collegamento gzcat.

Si veda in particolare gzip.info o gzip(1).

Alcune opzioni

-c | --stdout | --to-stdout

Emette il risultato attraverso lo standard output. gzip si comporta con questa opzione predefinita quando viene eseguito con il nome zcat.

-d | --decompress | --uncompress

Decomprime un file compresso. gzip si comporta con questa opzione predefinita quando viene eseguito con il nome gunzip.

-r | --recursive

Se tra i nomi indicati nella riga di comando appaiono delle directory, vengono compressi o decompressi tutti i file in esse contenuti.

-t | --test

Controlla l'integrità dei file compressi.

-1 | -2 | -3 | -4 | -5 | -6 | -7 | -8 | -9

Permette di definire il livello di compressione: -1 rappresenta la compressione minima, che in compenso richiede meno elaborazione; -9 rappresenta la compressione massima, a scapito del tempo di elaborazione. Se non viene specificata questa opzione, si utilizza un livello intermedio, corrispondente a -6.

Esempi

$ gzip *.sgml

Comprime i file *.sgml, utilizzando un livello intermedio di compressione, sostituendo i file originali con quelli compressi: *.sgml.gz.

$ gzip -d *.sgml.gz

Espande i file corrispondenti al modello *.sgml.gz, togliendo loro l'estensione .gz.

$ cat pippo | gzip -9 > pippo.gz

Genera il file pippo.gz come risultato della compressione di pippo. In particolare, viene utilizzato il livello di compressione massima e il file originale non viene cancellato.

$ cat pippo.gz | gzip -d > pippo

Fa l'opposto dell'esempio precedente: espande il file pippo.gz generando pippo, senza cancellare il file originale.

74.2.2 $ bzip2, bunzip2

bzip2 [opzioni] [file...]

bunzip2 [opzioni] [file...]

bzip2 ⁽⁴⁾ è un programma di compressione funzionalmente analogo a gzip, nel senso che viene creato un file compresso per ogni file indicato negli argomenti. bzip2, come gzip, è in grado di comprimere solo file normali, in modo singolo, dove per ogni file ne viene generato un altro con l'estensione .bz2. Se non viene indicato alcun file o se si utilizza espressamente un solo trattino isolato (-), lo standard input viene compresso e il risultato viene emesso attraverso lo standard output.

bzip2 utilizza un algoritmo di compressione differente, rispetto a gzip, con un carico di elaborazione maggiore, che diventa efficace solo in presenza di file di grandi dimensioni. In generale, per garantire la massima portabilità di un archivio compresso, conviene utilizzare gzip, salvo quando le dimensioni dell'archivio sono tali da rendere realmente conveniente l'utilizzo di bzip2.

La sintassi di bzip2 è molto simile a quella di gzip, anche se non è del tutto identica. Prima di decidere di utilizzare bzip2 per archiviare i propri dati, conviene leggere la documentazione originale, bzip2(1), in modo da poter valutare correttamente.

bunzip2 è un collegamento a bzip2, il quale, se avviato con questo nome, utilizza implicitamente l'opzione -d per decomprimere i file indicati alla fine della riga di comando.

Alcune opzioni

-c | --stdout

Comprime o decomprime emettendo il risultato attraverso lo standard output. La decompressione ammette l'emissione di più file, mentre in caso di compressione, se ne può emettere solo uno.

-d | --decompress

Forza la modalità di decompressione dei dati. bzip2 si comporta con questa opzione predefinita quando viene eseguito con il nome bunzip2.

-f | --compress

Forza la modalità di compressione dei dati. Serve a imporre la compressione, indipendentemente dal nome utilizzato per avviare bzip2.

-t | --test

Controlla l'integrità dei file compressi.

-1 | -2 | -3 | -4 | -5 | -6 | -7 | -8 | -9

Permette di definire il livello di compressione: -1 rappresenta la compressione minima, che in compenso richiede blocchi più piccoli (100 Kibyte) e meno elaborazione; -9 rappresenta la compressione massima, a scapito della dimensione dei blocchi che aumenta in modo considerevole (900 Kibyte) e del tempo di elaborazione.

74.2.3 Copie di sicurezza

Quello che segue è l'esempio di uno script molto semplice per l'archiviazione di una serie di file e directory attraverso la coppia tar e gzip.

#!/bin/sh
#======================================================================
# salva <directory-di-destinazione>  < <elenco>
#
# Archiviazione di tutti i file e directory indicati attraverso lo
# standard input, utilizzando <directory-di-destinazione> come luogo
# di destinazione degli archivi.
#
# Gli archivi vengono generati in formato .tgz, cioè tar+gzip.
#======================================================================

#======================================================================
# Variabili.
#======================================================================

    #------------------------------------------------------------------
    # L'elenco dei file e delle directory da archiviare proviene dallo
    # standard input.
    #------------------------------------------------------------------
    ELENCO_DA_ARCHIVIARE=`cat`
    #------------------------------------------------------------------
    # Directory di destinazione.
    #------------------------------------------------------------------
    DESTINAZIONE=$1

#======================================================================
# Funzioni.
#======================================================================

    #------------------------------------------------------------------
    # Visualizza la sintassi corretta per l'utilizzo di questo script.
    #------------------------------------------------------------------
    function sintassi () {
        echo ""
        echo "cat elenco | $0 <directory-di-destinazione>"
        echo ""
    }

#======================================================================
# Inizio.
#======================================================================

    #------------------------------------------------------------------
    # Verifica la quantità di argomenti.
    #------------------------------------------------------------------
    if [ $# != 1 ]
    then
        #--------------------------------------------------------------
        # La quantità di argomenti è errata. Richiama la funzione
        # «sintassi» e termina l'esecuzione dello script restituendo
        # un valore corrispondente a «falso».
        #--------------------------------------------------------------
        sintassi
        exit 1
    fi
    #------------------------------------------------------------------
    # Verifica se esiste la directory di destinazione.
    #------------------------------------------------------------------
    if [ -e $DESTINAZIONE ]
    then
        #--------------------------------------------------------------
        # Qualcosa con quel nome esiste già.
        # Si deve verificare che si tratti di una directory.
        #--------------------------------------------------------------
        if [ ! -d $DESTINAZIONE ]
        then
            #----------------------------------------------------------
            # Non si tratta di una directory.
            #----------------------------------------------------------
            echo "Non è possibile procedere con l'archiviazione"
            echo "perché $DESTINAZIONE esiste e non è una directory."
            #----------------------------------------------------------
            # Lo script termina restituendo un valore corrispondente
            # a «falso».
            #----------------------------------------------------------
            exit 1
        fi
    else
        #--------------------------------------------------------------
        # La directory non esiste.
        # Si tenta di crearla.
        #--------------------------------------------------------------
        if ! mkdir $DESTINAZIONE
        then
            #----------------------------------------------------------
            # Non è stato possibile creare la directory
            #----------------------------------------------------------
            echo "Non è possibile creare la directory"
            echo "$DESTINAZIONE"
            #----------------------------------------------------------
            # Lo script termina restituendo un valore corrispondente
            # a «falso».
            #----------------------------------------------------------
            exit 1
        fi
    fi
    #------------------------------------------------------------------
    # Giunti a questo punto, dovrebbe esistere la directory
    # di destinazione.
    # Inizia il ciclo di archiviazione.
    #------------------------------------------------------------------
    for DA_ARCHIVIARE in $ELENCO_DA_ARCHIVIARE
    do
        #--------------------------------------------------------------
        # Estrae il nome del file o della directory senza il suo
        # percorso.
        #--------------------------------------------------------------
        BASE_NAME=`basename $DA_ARCHIVIARE`
        #--------------------------------------------------------------
        # Comprime il file o il contenuto della directory ottenendo un
        # file compresso con lo stesso nome e l'aggiunta
        # dell'estensione «.tgz».
        # Si utilizza «tar» specificando in particolare l'opzione «z»
        # che permette di comprimere automaticamente l'archivio
        # attraverso «gzip»;
        #--------------------------------------------------------------
        tar czvf $DESTINAZIONE/$BASE_NAME.tgz $DA_ARCHIVIARE
    done
    #------------------------------------------------------------------
    # L'operazione di archiviazione e' terminata.
    #------------------------------------------------------------------
    echo "L'archiviazione e' terminata."

#======================================================================
# Fine.
#======================================================================

1) GNU cpio GNU GPL

2) GNU tar GNU GPL

3) Gzip GNU GPL

4) Bzip2 software libero con licenza speciale

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome archiviazione_e_compressione.html

[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]