Capitolo 356. Accorgimenti per una distribuzione Debian

In generale, la distribuzione GNU/Linux Debian non ha bisogno di accorgimenti particolari. In questo capitolo vengono annotate poche cose; in particolare sul modo di gestire una raccolta degli archivi Debian e sulla possibilità di realizzare una copia personalizzata della distribuzione.

356.1 Raccogliere gli aggiornamenti

La distribuzione Debian, data la sua natura collaborativa, è molto dinamica e nel susseguirsi delle sue edizioni viene prodotta una grande quantità di pacchetti aggiornati. Data la dimensione che ha raggiunto ormai la distribuzione, è improbabile che si riesca ad avere sempre una copia completa della distribuzione; piuttosto è facile trovare nelle riviste dei CD-ROM con questo o quel gruppo di applicativi, più o meno aggiornati. Volendo realizzare una propria copia locale della distribuzione (su disco fisso, o su dischi rimovibili), occorre realizzare qualche script per gestire un po' meglio la cosa.

356.1.1 Composizione del nome degli archivi Debian

Il nome degli archivi Debian è organizzato secondo la struttura seguente:

nome_del_pacchetto_versione_e_revisione.deb

Per essere precisi, questo è il nome normale, da utilizzare quando si conosce a quale architettura è destinato, in base alla directory in cui si trova a essere conservato.

Alle volte, per qualche ragione, il nome degli archivi che si trovano in circolazione non è conforme a questo modello; tuttavia, con l'aiuto delle informazioni contenute negli archivi stessi, è possibile riprodurre il nome standard. I comandi seguenti, che utilizzano dpkg, permettono di ottenere le informazioni necessarie a ricostruire il nome di un archivio Debian:

dpkg --field archivio package

restituisce il nome del pacchetto;

dpkg --field archivio version

Restituisce la stringa che rappresenta la versione e la revisione del pacchetto.

Quello che segue è l'esempio di uno script in grado di scandire gli archivi contenuti nella directory corrente, allo scopo di modificarne il nome se questo non corrisponde al modello standard. La scansione viene fatta in due fasi, per verificare alla fine quali archivi non sono stati corretti.

#!/bin/bash
#=======================================================================
# debian-nomi
#
# Interviene nella directory *corrente* correggendo i nomi degli
# archivi che sembrano non essere coerenti. Si utilizza in particolare:
#
#       dpkg --field <archivio> package
#       dpkg --field <archivio> version
#
#=======================================================================

#-----------------------------------------------------------------------
# Inizializza le variabili di ambiente che servono per accumulare
# i valori per il confronto.
#-----------------------------------------------------------------------
ARCHIVIO=""
PACCHETTO=""
VERSIONE=""
NOME_CORRETTO=""

#----------------------------------------------------------------------
# Inizia il ciclo di scansione degli archivi Debian che si trovano
# nella directory corrente.
# Prima fase silenziosa.
#----------------------------------------------------------------------
for ARCHIVIO in *.deb
do
    #------------------------------------------------------------------
    # Se il nome è «*.deb», non ci sono file del genere.
    #------------------------------------------------------------------
    if [ "$ARCHIVIO" = "*.deb" ]
    then
        #--------------------------------------------------------------
        # Non si fa nulla.
        #--------------------------------------------------------------
        exit
    fi

    #------------------------------------------------------------------
    # Estrae il nome del pacchetto.
    #------------------------------------------------------------------
    PACCHETTO=`dpkg --field $ARCHIVIO package`

    #------------------------------------------------------------------
    # Estrae la versione del pacchetto.
    #------------------------------------------------------------------
    VERSIONE=`dpkg --field $ARCHIVIO version`

    #------------------------------------------------------------------
    # Compone il nome teorico.
    #------------------------------------------------------------------
    NOME_CORRETTO="${PACCHETTO}_${VERSIONE}.deb"

    #------------------------------------------------------------------
    # Confronta con il nome dell'archivio.
    #------------------------------------------------------------------
    if [ "$NOME_CORRETTO" != "$ARCHIVIO" ]
    then
        #--------------------------------------------------------------
        # I nomi sono differenti.
        # Modifica il nome solo se è possibile.
        #--------------------------------------------------------------
        echo "n" | mv -i "$ARCHIVIO" "$NOME_CORRETTO" 2> /dev/null
    fi
done

#----------------------------------------------------------------------
# Inizia il ciclo di scansione degli archivi Debian che si trovano
# nella directory corrente.
# Seconda fase di verifica.
#----------------------------------------------------------------------
for ARCHIVIO in *.deb
do
    #------------------------------------------------------------------
    # Estrae il nome del pacchetto.
    #------------------------------------------------------------------
    PACCHETTO=`dpkg --field $ARCHIVIO package`

    #------------------------------------------------------------------
    # Estrae la versione del pacchetto.
    #------------------------------------------------------------------
    VERSIONE=`dpkg --field $ARCHIVIO version`

    #------------------------------------------------------------------
    # Compone il nome teorico.
    #------------------------------------------------------------------
    NOME_CORRETTO="${PACCHETTO}_${VERSIONE}.deb"

    #------------------------------------------------------------------
    # Confronta con il nome dell'archivio.
    #------------------------------------------------------------------
    if [ "$NOME_CORRETTO" != "$ARCHIVIO" ]
    then
        #--------------------------------------------------------------
        # A quanto pare, il nome di questo archivio non è stato
        # corretto.
        #--------------------------------------------------------------
        echo "Non è stato possibile correggere il nome dell'archivio"
        echo "$ARCHIVIO, che dovrebbe chiamarsi $NOME_CORRETTO."
        echo
    fi
done

#=======================================================================

356.1.2 Eliminazione delle versioni precedenti

La versione di un pacchetto è composta da due parti: la versione (vera e propria) e la revisione. Si tratta di due stringhe unite da un trattino:

versione-revisione

In generale, non è facile confrontare questi valori e per fortuna viene in aiuto dpkg che è in grado di affermare quale sia più recente. In pratica, si utilizza uno dei comandi seguenti, per determinare se una versione è maggiore, minore o uguale all'altra:

dpkg --compare-versions versione1 gt versione2

dpkg --compare-versions versione1 lt versione2

dpkg --compare-versions versione1 eq versione2

Lo script seguente serve a scandire gli archivi Debian contenuti nella directory corrente, allo scopo di eliminare quelli che contengono uno stesso pacchetto ma di una versione precedente a quanto già disponibile. Durante la scansione, si presume che i nomi degli archivi siano composti correttamente, in modo tale che gli archivi di uno stesso pacchetto si trovino di seguito, nella sequenza alfabetica.

#!/bin/bash
#=======================================================================
# debian-doppi
#
# Interviene nella directory *corrente* eliminando i file doppi,
# più vecchi. Il confronto viene fatto utilizzando:
#
#       dpkg --field <archivio> package
#       dpkg --field <archivio> version
#       dpkg --compare-versions <versione1> eq <versione0>
#       dpkg --compare-versions <versione1> gt <versione0>
#       dpkg --compare-versions <versione1> lt <versione0>
#
#=======================================================================

#-----------------------------------------------------------------------
# Inizializza le variabili di ambiente che servono per accumulare
# i valori per il confronto.
#-----------------------------------------------------------------------
ARCHIVIO0=""
ARCHIVIO1=""
PACCHETTO0=""
PACCHETTO1=""
VERSIONE0=""
VERSIONE1=""

#----------------------------------------------------------------------
# Inizia il ciclo di scansione degli archivi Debian che si trovano
# nella directory corrente.
#----------------------------------------------------------------------
for ARCHIVIO1 in *.deb
do
    #------------------------------------------------------------------
    # Se il nome è «*.deb», non ci sono file del genere.
    #------------------------------------------------------------------
    if [ "$ARCHIVIO1" = "*.deb" ]
    then
        #--------------------------------------------------------------
        # Non si fa nulla.
        #--------------------------------------------------------------
        exit
    fi

    #------------------------------------------------------------------
    # Estrae il nome del pacchetto.
    #------------------------------------------------------------------
    PACCHETTO1=`dpkg --field $ARCHIVIO1 package`

    #------------------------------------------------------------------
    # Estrae la versione del pacchetto.
    #------------------------------------------------------------------
    VERSIONE1=`dpkg --field $ARCHIVIO1 version`

    #------------------------------------------------------------------
    # Confronta con il pacchetto precedente.
    #------------------------------------------------------------------
    if [ "$PACCHETTO1" == "$PACCHETTO0" ]
    then
        if dpkg --compare-versions "$VERSIONE1" eq "$VERSIONE0"
        then
            #----------------------------------------------------------
            # Si tratta di un'anomalia in cui si deve intervenire a
            # mano.
            #----------------------------------------------------------
            echo "Gli archivi seguenti hanno la stessa versione:"
            echo "    $ARCHIVIO0"
            echo "    $ARCHIVIO1"
            echo

            #----------------------------------------------------------
            # In questo caso, non occorre spostare i valori nelle
            # variabili.
            #----------------------------------------------------------
            
        elif dpkg --compare-versions "$VERSIONE1" gt "$VERSIONE0"
        then
            #----------------------------------------------------------
            # Si elimina l'archivio del pacchetto più vecchio.
            #----------------------------------------------------------
            rm -f "$ARCHIVIO0"
            echo "Eliminato $ARCHIVIO0"

            #----------------------------------------------------------
            # Sposta i valori nelle variabili.
            #----------------------------------------------------------
            ARCHIVIO0="$ARCHIVIO1"
            PACCHETTO0="$PACCHETTO1"
            VERSIONE0="$VERSIONE1"

        elif dpkg --compare-versions "$VERSIONE1" lt "$VERSIONE0"
        then
            #----------------------------------------------------------
            # Si elimina l'archivio del pacchetto più vecchio.
            #----------------------------------------------------------
            rm -f "$ARCHIVIO1"
            echo "Eliminato $ARCHIVIO1"

            #----------------------------------------------------------
            # In questo caso, non occorre spostare i valori nelle
            # variabili.
            #----------------------------------------------------------

        else
            #----------------------------------------------------------
            # Questo caso non dovrebbe verificarsi.
            #----------------------------------------------------------
            echo "C'è un errore nel confronto degli archivi seguenti:"
            echo "    $ARCHIVIO0"
            echo "    $ARCHIVIO1"
            echo

            #----------------------------------------------------------
            # In questo caso, non occorre spostare i valori nelle
            # variabili.
            #----------------------------------------------------------
        fi

    else
        #--------------------------------------------------------------
        # Dal momento che i pacchetti sono differenti, si devono
        # salvare le variabili prima di procedere.
        #--------------------------------------------------------------
        ARCHIVIO0="$ARCHIVIO1"
        PACCHETTO0="$PACCHETTO1"
        VERSIONE0="$VERSIONE1"
    fi
done

#=======================================================================

356.2 Realizzazione di una copia personale della distribuzione

Per comprendere come realizzare una copia locale della distribuzione GNU/Linux Debian, occorre andare per gradi, partendo dal caso in cui questa è disponibile completamente in un supporto unico, per poi arrivare a comprendere le differenze che si devono introdurre per ottenere una versione distribuita su più supporti.

356.2.1 Distribuzione completa su un supporto unico

Si suppone che l'utente tizio voglia predisporre una copia locale della distribuzione Debian, a partire dalla directory /home/tizio/DEBIAN/. La struttura minima che dovrebbe articolarsi a partire da questa directory dovrebbe essere quella che si vede nella figura 356.1.

Figura 356.1. Struttura minima di una distribuzione GNU/Linux Debian organizzata in modo da utilizzare un supporto unico.

debian/
  |-- dists/
  |     |-- stable --> ../codename
  |     |
  |     `-- codename/
  |           |
  |           |-- main/
  |           |     |-- disks-arch/
  |           |     |     `-- current/
  |           |     |
  |           |     `-- binary-arch/
  |           |           |-- Packages
  |           |           |-- Packages.gz
  |           |           |-- admin/
  |           |           |-- base/
  |           |           |-- comm/
  |           |           :
  |           |           
  |           |-- contrib/
  |           |     |
  |           |     `-- binary-arch/
  |           |           |-- Packages
  |           |           |-- Packages.gz
  |           |           :
  |           |           
  |           |-- non-free/
  |           |     :      
  |           |           
  |           |-- non-US/
  |           |     :      
  |           |           
  |           `-- local/
  |                 :      
  |
  `-- indices/
        `-- override.gz

In breve, viene descritto il senso di questa struttura.

La directory debian/dists/stable/main/disks-i386/current/ contiene i file delle immagini dei dischetti (per l'architettura i386) da utilizzare per avviare l'installazione e per riprodurre il sistema minimo precedente alla selezione dei pacchetti.
Le directory debian/dists/stable/*/binary-i386/ contengono la gerarchia finale dei pacchetti di ogni gruppo (main/, contrib/, non-free/, non-US/ e local/), che potrebbe essere suddivisa o meno in sezioni (admin/, base/, ecc.). Da quel punto, poi, si inseriscono gli archivi Debian.
I file Packages e Packages.gz, contenuti nelle directory debian/dists/stable/*/binary-i386/, sono indispensabili per fornire ai programmi come DSelect e APT le informazioni importanti sui pacchetti.
Il file, o i file debian/indices/override*.gz servono per ricostruire correttamente i file Packages.

Il problema nella riproduzione di una distribuzione Debian sta nella creazione dei file Packages (e di conseguenza anche Packages.gz). Per arrivare a questo risultato, occorre definire una stringa che serva a individuare la distribuzione, per esempio:

Debian GNU/Linux 2.1 slink personalizzata

Inoltre occorre un file override (debian/indices/override.gz o un altro nome simile), contenente l'abbinamento tra i pacchetti, la priorità e la classificazione in sezioni, come nell'estratto seguente:

at              important       admin
cron            important       admin
locales         standard        admin
ncurses-term    standard        admin
acct            optional        admin
adjtimex        optional        admin
    ...
adduser         required        base
ae              required        base
amiga-fdisk     required        base
    ...
lilo            important       base
silo            important       base
    ...
newt0.25        optional        base
ppp             optional        base
pppconfig       optional        base
syslinux        optional        base
    ...

Infine occorrono i pacchetti, che si trovano lì dove sono. I file override vanno prelevati da una delle varie riproduzioni speculari, tenendo presente che possono essere aggiornati frequentemente. Di solito, questi file sono suddivisi in base ai raggruppamenti principali in cui si articola una versione: main/, contrib/,... Per semplificare le operazioni, può convenire la realizzazione di un file unico, come è stato mostrato nella struttura di esempio. A questo file si farà riferimento come override.gz.⁽¹⁾

Disponendo di questo materiale, si può utilizzare dpkg-scanpackages per rigenerare i file Packages. Eventualmente si può vedere la pagina di manuale dpkg-scanpackages(8).

tizio$ cd /home/tizio/DEBIAN/debian

Ci si posiziona nella directory principale della distribuzione.

tizio$ dpkg-scanpackages _<-'
^`->-m "Debian GNU/Linux 2.1 slink personalizzata" _<-'
^`->dists/stable/main/binary-i386 indices/override.gz _<-'
^`->> dists/stable/main/binary-i386/Packages

Si genera il file Packages per il gruppo di pacchetti della classificazione main/ (il comando è stato mostrato suddiviso su più righe per motivi tipografici).

tizio$ cat dists/stable/main/binary-i386/Packages _<-'
^`->| gzip | dists/stable/main/binary-i386/Packages.gz

Si genera il file Packages.gz, comprimendo Packages creato precedentemente.

In seguito, si fa la stessa cosa per i raggruppamenti contrib/, non-free/, non-US/ e local/.

Anche se alcuni di questi raggruppamenti non vengono utilizzati, nel senso che non si vogliono tenere pacchetti che vi appartengano, è molto importante che siano predisposte le directory vuote e anche i file Packages*, per facilitare le operazioni con DSelect e APT.

dpkg-scanpackages può generare delle segnalazioni di errore, in particolare quando trova un pacchetto che non è indicato nel file override. In generale questo non provoca conseguenze gravi, tranne la mancanza di qualche informazione per quel pacchetto.

L'esempio seguente è un estratto di uno dei file Packages, dove si vede la descrizione del pacchetto wget. Si deve osservare in particolare che le informazioni dei campi Priority e Section sono state determinate in base al file override, mentre la descrizione del campo X-Medium è stata ottenuta dall'opzione -m di dpkg-scanpackages.

Package: wget
Version: 1.5.3-1.1
Priority: optional
Section: web
Maintainer: Nicolás Lichtmaier <nick@feedback.net.ar>
Depends: libc6
Architecture: i386
Filename: dists/stable/main/binary-i386/wget_1.5.3-1.1.deb
Size: 221932
MD5sum: 323962a35dabbf88edfe665ad70eb382
Description: utility to retrieve files from the WWW via HTTP and FTP
 Wget [formerly known as Geturl] is a freely available network utility
 to retrieve files from the World Wide Web using HTTP and FTP, the two
 most widely used Internet protocols.  It works non-interactively, thus
 enabling work in the background, after having logged off.
 .
 The recursive retrieval of HTML pages, as well as FTP sites is
 supported -- you can use Wget to make mirrors of archives and home
 pages, or traverse the web like a WWW robot (Wget understands
 /robots.txt).
installed-size: 535
X-Medium: Debian GNU/Linux 2.1 slink personalizzata

Per accedere facilmente a questa distribuzione locale, basta configurare APT attraverso il file /etc/apt/sources.list:

deb file:/home/tizio/DEBIAN/debian stable main contrib non-free non-US local

Se le dimensioni lo consentono, si può trasferire una copia della gerarchia /home/tizio/DEBIAN/ in un disco rimovibile, o in un CD-ROM.

356.2.2 Distribuzione suddivisa su diversi supporti

Se si vuole masterizzare un CD-R, o comunque si vuole fare una copia della distribuzione suddividendola in più supporti, le cose si complicano. Per prima cosa si deve iniziare da una copia locale organizzata già nelle suddivisioni che si vogliono ottenere. Supponendo di partire dalla directory /home/tizio/DEBIAN/, conviene aggiungere altre sottodirectory ulteriori, una per ogni suddivisione che si vuole ottenere: 1/, 2/,...

La struttura della gerarchia che si articola a partire da queste sottodirectory deve essere la stessa, anche quando alcuni gruppi di pacchetti (main/, contrib/, ecc.) risultano senza archivi. La figura 356.2 mostra le varianti rispetto al modello già mostrato.

Figura 356.2. Struttura minima di una distribuzione GNU/Linux Debian organizzata in modo da utilizzare più supporti.

debian/
  |-- .disk/
  |     `-- info
  |
  |-- local/
  |     `-- local --> ../stable/local
  |
  |-- dists/
  |     |-- stable --> ../codename
  |     |
  |     `-- codename/
  |           |-- main/
  |           |     |
  |           |     |-- disks-arch/
  |           |     |     `-- current/
  |           |     |
  |           |     `-- binary-arch/
  |           |           |-- Packages
  |           |           |-- Packages.gz
  |           |           |-- Packages.cd
  |           |           |-- Packages.cd.gz
  |           |           :
  |           |
  |           |-- contrib/
  |           |     :
  |           |           
  |           |-- non-free/
  |           |     :
  |           |           
  |           |-- non-US/
  |           |     :
  |           |           
  |           `-- local/
  |                 :
  |
  `-- indices/
        `-- override.gz

Rispetto alla situazione precedente, si aggiunge il file debian/.disk/info, che deve contenere la stringa di descrizione del supporto, una cosa del tipo

Debian GNU/Linux 2.1 slink personalizzata disco 1

oppure

Debian GNU/Linux 2.1 slink personalizzata disco 2

ecc., mentre nelle directory debian/dists/stable/*/binary-i386/ appaiono dei file nuovi: Packages.cd e Packages.cd.gz. Infine, il raggruppamento di pacchetti local, dovrebbe trovarsi nella directory debian/dists/local/local/. Probabilmente, conviene realizzare un collegamento simbolico per portarlo nella collocazione normale.

I supporti distinti, vengono riconosciuti in base alla stringa contenuta nel file debian/.disk/info, che va scelta opportunamente e va utilizzata anche per la definizione del campo X-Medium.

Si comincia dalla preparazione dei file Packages e Packages.gz, più o meno come è stato fatto nella situazione precedente:

tizio$ cd /home/tizio/DEBIAN/1/debian

tizio$ dpkg-scanpackages -m `cat .disk/info` _<-'
^`->dists/stable/main/binary-i386 indices/override.gz _<-'
^`->> dists/stable/main/binary-i386/Packages

tizio$ cat dists/stable/main/binary-i386/Packages _<-'
^`->| gzip | dists/stable/main/binary-i386/Packages.gz

Come prima, si fa la stessa cosa per gli altri gruppi di pacchetti e poi si ripete il procedimento per la copia contenuta nella directory /home/tizio/DEBIAN/2/ (si suppone che si tratti di una suddivisione in due soli supporti):

tizio$ cd /home/tizio/DEBIAN/2/debian

tizio$ dpkg-scanpackages -m `cat .disk/info` _<-'
^`->dists/stable/main/binary-i386 indices/override.gz _<-'
^`->> dists/stable/main/binary-i386/Packages

tizio$ cat dists/stable/main/binary-i386/Packages _<-'
^`->| gzip | dists/stable/main/binary-i386/Packages.gz

Alla fine, si devono realizzare i file Packages.cd, che si compongono della somma dei file Packages di ogni gruppo:

tizio$ cd /home/tizio/DEBIAN/

tizio$ cat 1/debian/dists/stable/main/binary-i386/Packages _<-'
^`->2/debian/dists/stable/main/binary-i386/Packages _<-'
^`->> 1/debian/dists/stable/main/binary-i386/Packages.cd

tizio$ cat 1/debian/dists/stable/main/binary-i386/Packages _<-'
^`->2/debian/dists/stable/main/binary-i386/Packages _<-'
^`->> 2/debian/dists/stable/main/binary-i386/Packages.cd

tizio$ cat 1/debian/dists/stable/main/binary-i386/Packages.cd _<-'
^`->| gzip | 1/debian/dists/stable/main/binary-i386/Packages.cd.gz

tizio$ cat 2/debian/dists/stable/main/binary-i386/Packages.cd _<-'
^`->| gzip | 2/debian/dists/stable/main/binary-i386/Packages.cd.gz

In pratica, i file Packages.cd contengono le informazioni su tutti i pacchetti del proprio gruppo; sia quelli presenti effettivamente nel supporto che quelli che si trovano negli altri. I programmi come DSelect distingueranno il supporto in base al nome che gli è stato attribuito, indicato nel file debian/.disk/info e riportato nel campo X-Medium dei file Packages.cd*.

Per accedere facilmente a questa distribuzione locale, spezzata in due o più parti, basta configurare APT attraverso il file /etc/apt/sources.list:

deb file:/home/tizio/DEBIAN/1/debian stable main contrib non-free non-US local
deb file:/home/tizio/DEBIAN/2/debian stable main contrib non-free non-US local
# ...

Per copiare le due strutture in dischi separati, basta trasferire una copia delle gerarchie /home/tizio/DEBIAN/*/.

356.3 Riferimenti

Susan G. Kleinmann, Sven Rudolph, Joost Witteveen, The Debian GNU/Linux FAQ, 1999

<http://ftp.it.debian.org/debian/doc/FAQ/>
Ian Jackson, Christian Schwarz, Debian Policy Manual, 1998

<http://ftp.it.debian.org/debian/doc/package-developer/policy.txt.gz>

<http://ftp.it.debian.org/debian/doc/package-developer/policy.html.tar.gz>

<http://ftp.it.debian.org/debian/doc/package-developer/policy.pdf.gz>

<http://ftp.it.debian.org/debian/doc/package-developer/policy.ps.gz>

1) I file override originali della distribuzione slink hanno i nomi: override.slink.gz, override.slink.contrib.gz, override.slink.non-free.gz e override.slink.non-US.gz. Per realizzare la propria copia della distribuzione, nulla vieta di fonderli tutti assieme in un file unico, come descritto in questi esempi, dove si fa riferimento a un solo file override.gz.