[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [volume] [parte]

Capitolo 68. Pacchetti Debian: accorgimenti

In questo capitolo viene annotato un modo di gestire una raccolta degli archivi Debian, con la possibilità di realizzare una copia personalizzata della distribuzione.

68.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 o dei DVD-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.

68.1.1 Composizione del nome degli archivi Debian

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

{nome_del_pacchetto}_{versione_e_revisione}[_architettura].deb

Come si vede, la parte finale, che specifica l'architettura per la quale è predisposto un archivio, potrebbe anche essere omessa, se il contesto rende implicita questa informazione.

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.
dpkg --field archivio architecture
restituisce la stringa che rappresenta l'architettura per cui è fatto il 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 (una copia di questo file, dovrebbe essere disponibile anche qui: <allegati/a2/debian-nomi>).

#!/bin/sh
##
## 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
##       dpkg --field <archivio> architecture
##
#
# Inizializza le variabili di ambiente che servono per accumulare
# i valori per il confronto.
#
ARCHIVIO=""
PACCHETTO=""
VERSIONE=""
ARCHITETTURA=""
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`
    #
    # Estrae la sigla dell'architettura.
    #
    ARCHITETTURA=`dpkg --field $ARCHIVIO architecture`
    #
    # Compone il nome teorico.
    #
    NOME_CORRETTO="${PACCHETTO}_${VERSIONE}_${ARCHITETTURA}.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`
    #
    # Estrae la sigla dell'architettura.
    #
    ARCHITETTURA=`dpkg --field $ARCHIVIO architecture`
    #
    # Compone il nome teorico.
    #
    NOME_CORRETTO="${PACCHETTO}_${VERSIONE}_${ARCHITETTURA}.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
#

68.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 (una copia di questo file, dovrebbe essere disponibile anche qui: <allegati/a2/debian-doppi>).

#!/bin/sh
##
## 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 --field <archivio> architecture
##       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=""
ARCHITETTURA0=""
ARCHITETTURA1=""
#
# 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`
    #
    # Estrae l'architettura.
    #
    ARCHITETTURA1=`dpkg --field $ARCHIVIO1 architecture`
    #
    # 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"
            ARCHITETTURA0="$ARCHITETTURA1"
            #
        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"
        ARCHITETTURA0="$ARCHITETTURA1"
    fi
done
#

68.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ù unità di memorizzazione.

68.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 è quella che si vede nella figura 68.3.

Figura 68.3. 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 x86) 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 fa riferimento come override.gz.

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.

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[Invio]

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[Invio]

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[Invio]

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.

Il programma 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, come un CD-ROM o un DVD-ROM.

68.2.2 Distribuzione suddivisa su diversi supporti

Se si vuole masterizzare un CD/DVD, 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 68.8 mostra le varianti rispetto al modello già mostrato.

Figura 68.8. 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 simile ai due esempi seguenti:

Debian GNU/Linux 2.1 slink personalizzata disco 1

Debian GNU/Linux 2.1 slink personalizzata disco 2

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[Invio]

tizio$ dpkg-scanpackages -m `cat .disk/info` \
\dists/stable/main/binary-i386 indices/override.gz \
\> dists/stable/main/binary-i386/Packages[Invio]

tizio$ cat dists/stable/main/binary-i386/Packages \
\| gzip | dists/stable/main/binary-i386/Packages.gz[Invio]

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[Invio]

tizio$ dpkg-scanpackages -m `cat .disk/info` \
\dists/stable/main/binary-i386 indices/override.gz \
\> dists/stable/main/binary-i386/Packages[Invio]

tizio$ cat dists/stable/main/binary-i386/Packages \
\| gzip | dists/stable/main/binary-i386/Packages.gz[Invio]

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/[Invio]

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[Invio]

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[Invio]

tizio$ cat 1/debian/dists/stable/main/binary-i386/Packages.cd \
\| gzip | 1/debian/dists/stable/main/binary-i386/Packages.cd.gz[Invio]

tizio$ cat 2/debian/dists/stable/main/binary-i386/Packages.cd \
\| gzip | 2/debian/dists/stable/main/binary-i386/Packages.cd.gz[Invio]

In pratica, i file Packages.cd contengono le informazioni su tutti i pacchetti del proprio gruppo; sia quelli presenti effettivamente nel supporto, sia quelli che si trovano negli altri. I programmi come DSelect distinguono 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/*/.

68.3 Un esempio banalizzato, ma funzionante

Viene proposta in questa sezione una struttura semplificata per ospitare i pacchetti Debian che si raccolgono qua e là. Si parte da una struttura di alcuni file e directory, che per il momento viene semplificata:

.
|-- DIST
|-- Packages.cd.gz
|-- dists/
|   |-- 00 -> /tmp
|   |-- 01/
|   |-- 02/
|   `-- 03/
|-- indices/
|   |-- Maintainers.gz
|   |-- override.gz
|   `-- pubring.pgp
`-- make-packages

Si può osservare che la directory dists/00/ è in realtà un collegamento simbolico alla directory temporanea (/tmp/).

Il file DIST deve contenere una riga con la denominazione della distribuzione, che eventualmente può limitarsi a essere:

Debian GNU/Linux

I file Packages.cd.gz, indices/Maintainers.gz e indices/override.gz sono file compressi con gzip, a partire da file completamente vuoti; il file indices/pubring.pgp è vuoto.

All'interno delle directory dists/01/, dists/02/ e dists/03/ ci sono una serie di collegamenti simbolici identici nei tre casi:

.
|-- dists/
|   |-- 01/
|   |   |-- binary-all -> .
|   |   |-- binary-i386 -> .
|   |   |-- contrib -> .
|   |   |-- local -> .
|   |   |-- main -> .
|   |   |-- non-US -> .
|   |   `-- non-free -> .
:   :

Con questa struttura, si possono mettere i file degli archivi Debian nelle directory dists/01/, dists/02/ e dists/03/, tenendo conto che in presenza di pacchetti doppi, ma con versione differente, quelli riferiti alla versione più vecchia vengono spostati a un livello precedente tramite uno script. In pratica, secondo questa sistemazione, i pacchetti che si raccolgono vanno inseriti soltanto nella directory dists/03/, dalla quale i più vecchi vengono spostati automaticamente all'interno di dists/02/, di dists/01/ e di dists/00/, ma dato che dists/00 è in realtà un collegamento simbolico a /tmp/, l'ultimo passaggio è semplicemente un modo per eliminarli. Così facendo, anche se si aggiornano i pacchetti, rimane una copia di scorta delle versioni precedenti.

Lo script che fa il lavoro è make-packages, che va avviato mentre la directory corrente corrisponde all'inizio della struttura; pertanto va avviato così:

$ ./make-packages[Invio]

Lo script crea anche il file .disk/info e il file error-messages (una copia di questo file, dovrebbe essere disponibile anche qui: <allegati/a2/make-packages>).

Listato 68.15. Lo script make-packages.

#!/bin/sh
##
## make-packages
##
#
# la directory di partenza deve essere quella da cui si dirama la
# directory "dists/"
#
START_DIR=`pwd`
#
# Definisce il file da usare per i messaggi di errore e lo svuota.
#
ERROR_MESSAGES="$START_DIR/error-messages"
echo > $ERROR_MESSAGES
#
# Definisce il contenuto dei file ".disk/info"
# ATTENZIONE! il file ".disk/info" è obbligatorio per "dselect"!
#
DISTRIBUTION=`cat $START_DIR/DIST`
DATE=`date "+%Y.%m.%d %H:%M"`
rm -rf $START_DIR/.disk
mkdir $START_DIR/.disk
echo "$DISTRIBUTION $DATE" > $START_DIR/.disk/info
#
# Carica il nome che identifica i supporti.
# ATTENZIONE! il file ".disk/info" è obbligatorio per "dselect"!
#
MEDIA=`cat .disk/info`
#
# Dichiara la funzione che sistema i file.
#
function debian_arrange_files ()
{
    DISTRIBUTION="$1"
    PREVIOUS_LEVEL="$2"
    #
    # Inizializza le variabili di ambiente che servono per accumulare
    # i valori per il confronto.
    #
    ARCHIVE_0=""
    ARCHIVE_1=""
    #
    PACKAGE_0=""
    PACKAGE_1=""
    #
    VERSION_0=""
    VERSION_1=""
    #
    ARCHITECTURE_0=""
    ARCHITECTURE_1=""
    #
    CORRECT_NAME_0=""
    CORRECT_NAME_1=""
    #
    # Inizia il ciclo di scansione degli archivi Debian che si trovano
    # nella directory corrente.
    #
    for ARCHIVE_1 in *.deb
    do
        #
        # Se il nome è «*.deb», non ci sono file del genere.
        #
        if [ "$ARCHIVE_1" = "*.deb" ]
        then
            #
            # Non si fa nulla.
            #
            return
        fi
        #
        # Estrae il nome del pacchetto.
        #
        PACKAGE_1=`dpkg --field $ARCHIVE_1 package`
        #
        # Estrae la versione del pacchetto.
        #
        VERSION_1=`dpkg --field $ARCHIVE_1 version`
        #
        # Estrae il nome dell'architettura.
        #
        ARCHITECTURE_1=`dpkg --field $ARCHIVE_1 architecture`
        #
        # Compone il nome teorico.
        #
        CORRECT_NAME_1="${PACKAGE_1}_${VERSION_1}_${ARCHITECTURE_1}.deb"
        #
        # Confronta con il nome dell'archivio.
        #
        if [ "$CORRECT_NAME_1" != "$ARCHIVE_1" ]
        then
            #
            # I nomi sono differenti.
            #
            # Modifica il nome forzando la situazione (prima si usava
            # l'opzione -i).
            #
            echo "n" | mv -f "$ARCHIVE_1" "$CORRECT_NAME_1" 2> /dev/null
            echo "$ARCHIVE_1 ---> $CORRECT_NAME_1"
            #
            echo "$ARCHIVE_1 ---> $CORRECT_NAME_1" \
                 >> $ERROR_MESSAGES
            #
            # Meglio annotare il nome nuovo nella variabile.
            #
            ARCHIVE_1="$CORRECT_NAME_1"
            #
        fi
        #
        # Confronta con il pacchetto precedente.
        #
        if [ "$PACKAGE_1" == "$PACKAGE_0" ]
        then
            if dpkg --compare-versions "$VERSION_1" eq "$VERSION_0"
            then
                #
                # Si tratta di un'anomalia in cui si deve intervenire a
                # mano.
                #
                echo "Same version: $ARCHIVE_0 $ARCHIVE_1"
                #
                echo "Same version: $ARCHIVE_0 $ARCHIVE_1"\
                     >> $ERROR_MESSAGES
                #
                # In questo caso, non occorre spostare i valori nelle
                # variabili.
                #
            elif dpkg --compare-versions "$VERSION_1" gt "$VERSION_0"
            then
                #
                # Si sposta l'archivio doppio nel livello precedente.
                #
                echo "$DISTRIBUTION/$ARCHIVE_0 --> $PREVIOUS_LEVEL"
                mv $ARCHIVE_0 ../$PREVIOUS_LEVEL/$ARCHIVE_0
                #
                # Sposta i valori nelle variabili.
                #
                ARCHIVE_0="$ARCHIVE_1"
                PACKAGE_0="$PACKAGE_1"
                ARCHITECTURE_0="$ARCHITECTURE_1"
                VERSION_0="$VERSION_1"
                CORRECT_NAME_0="$CORRECT_NAME_1"
                #
            elif dpkg --compare-versions "$VERSION_1" lt "$VERSION_0"
            then
                #
                # Si sposta l'archivio doppio nel livello precedente.
                #
                echo "$DISTRIBUTION/$ARCHIVE_1 --> $PREVIOUS_LEVEL"
                mv $ARCHIVE_1 ../$PREVIOUS_LEVEL/$ARCHIVE_1
                #
                # In questo caso, non occorre spostare i valori nelle
                # variabili.
                #
            else
                #
                # Questo caso non dovrebbe verificarsi.
                #
                echo "There is an error matching the following archives:"
                echo "    $ARCHIVE_0"
                echo "    $ARCHIVE_1"
                #
                echo "There is an error matching the following archives:"\
                     >> $ERROR_MESSAGES
                echo "    $ARCHIVE_0"\
                     >> $ERROR_MESSAGES
                echo "    $ARCHIVE_1"\
                     >> $ERROR_MESSAGES
                #
                # 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.
            #
            ARCHIVE_0="$ARCHIVE_1"
            PACKAGE_0="$PACKAGE_1"
            ARCHITECTURE_0="$ARCHITECTURE_1"
            VERSION_0="$VERSION_1"
            CORRECT_NAME_0="$CORRECT_NAME_1"
            #
            # mostra cosa è stato fatto
            #
            echo "$PACKAGE_1"
        fi
    done
}
#
# Dichiara la funzione che esegue le operazioni ripetitive su
# ogni sezione di ogni distribuzione, per ogni disco.
#
function process_disk_distribution_section ()
{
    MEDIA="$1"
    DISTRIBUTION="$2"
    PREVIOUS_LEVEL="$3"
    SECTION="$4"
    #
    echo "$MEDIA, $DISTRIBUTION, $SECTION" 
    #
    cd $START_DIR/dists/$DISTRIBUTION/$SECTION/binary-i386
    debian_arrange_files $DISTRIBUTION $PREVIOUS_LEVEL
    #
    cd $START_DIR
    dpkg-scanpackages                                           \
        dists/$DISTRIBUTION/$SECTION/binary-i386                \
        $START_DIR/indices/override.gz                          \
        > dists/$DISTRIBUTION/$SECTION/binary-i386/Packages     \
        2>> $ERROR_MESSAGES
    #
    cat dists/$DISTRIBUTION/$SECTION/binary-i386/Packages       \
        | gzip -9                                               \
        > dists/${DISTRIBUTION}/$SECTION/binary-i386/Packages.gz
}
#
# Funzione frontale.
#
function process_section () {
    DISTRIBUTION="$1"
    PREVIOUS_LEVEL="$2"
    SECTION="$3"
    #
    process_disk_distribution_section "$MEDIA" $DISTRIBUTION\
                                      $PREVIOUS_LEVEL $SECTION
    #
    # Prepara i file "Packages.cd" e "Packages.cd.gz"
    #
    cd $START_DIR
    #
    cat dists/$DISTRIBUTION/$SECTION/binary-i386/Packages       \
        > dists/$DISTRIBUTION/$SECTION/binary-i386/Packages.cd
    #
    cd $START_DIR/dists/$DISTRIBUTION/$SECTION/binary-i386
    cat Packages.cd | gzip -9 > Packages.cd.gz
    #
    cd $START_DIR
}
#
# Inizia il programma.
#
cd $START_DIR
#
process_section 03 02 main
process_section 02 01 main
process_section 01 00 main

68.4 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://www.debian.org/doc/debian-policy/>

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome pacchetti_debian_accorgimenti.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico]