Capitolo 6. Costruzione del pacchetto

# Capitolo 6. Costruzione del pacchetto

È disponibile la riscrittura di questo tutorial, con contenuti aggiornati e con esempi più pratici, denominato Guide for Debian Maintainers. Si prega di utilizzare il nuovo tutorial come documento primario.

A questo punto, si dovrebbe essere pronti a creare il pacchetto.

## 6.1. (ri)Creazione completa

Al fine di (ri)creare un pacchetto in modo appropriato, è necessario assicurarsi di installare

- il pacchetto `build-essential`,

- i pacchetti elencati nel campo `Build-Depends` (vedere Sezione 4.1, «`control`»), e

- i pacchetti elencati nel campo `Build-Depends-indep` (vedere Sezione 4.1, «`control`»).

Adesso ci si sposti nella directory dei sorgenti del programma e si lanci il comando:

    $ dpkg-buildpackage -us -uc

Questo comando creerà i pacchetti binari e sorgenti al posto vostro. Eseguirà le seguenti operazioni:

- pulirà l'albero dei sorgenti (`debian/rules clean`)

- costruirà il pacchetto sorgente (`dpkg-source -b`)

- costruirà il programma (`debian/rules build`)

- costruirà il pacchetto binario (`fakeroot debian/rules binary`)

- crea il file `.dsc`

- crea il file `.changes`, utilizzando dpkg-genchanges

Se si è soddisfatti del pacchetto generato, si firmino i file `.dsc` e `.changes` con la chiave GPG privata utilizzando il comando debsign. È necessario inserire la propria passphrase segreta due volte. [62]

Per un pacchetto Debian non-nativo, per esempio, `gentoo`, si vedano i seguenti file nella directory superiore (`~/gentoo`) dopo la creazione dei pacchetti:

- `gentoo_0.9.12.orig.tar.gz`

  Questo è il codice sorgente originale, semplicemente rinominato in modo da aderire allo standard Debian. Da notare che questo è stato creato inizialmente con il comando `dh_make -f ../gentoo-0.9.12.tar.gz`.

- `gentoo_0.9.12-1.dsc`

  Questo è un sommario del contenuto del codice sorgente. Questo file è generato dal file `control`, ed è usato quando si decomprime il sorgente con dpkg-source(1).

- `gentoo_0.9.12-1.debian.tar.gz`

  Questo file compresso contiene il contenuto della directory `debian`. Ogni modifica effettuata al codice sorgente originale, verrà memorizzata come patch di quilt in `debian/patches`.

  Se qualcun altro volesse ri-creare il pacchetto da zero, potrebbe farlo facilmente usando i suddetti tre file. La procedura di estrazione è banale: basta copiare i tre file da qualche parte ed eseguire `dpkg-source -x gentoo_0.9.12-1.dsc`. [63]

- `gentoo_0.9.12-1_i386.deb`

  Questo è il pacchetto binario completo. Si può usare dpkg per installarlo e rimuoverlo, come per ogni altro pacchetto.

- `gentoo_0.9.12-1_i386.changes`

  Questo file descrive tutte le modifiche effettuate nella revisione corrente del pacchetto; è usata dai programmi di manutenzione dell'archivio FTP di Debian, per installare i pacchetti binari e sorgenti. È generato parzialmente dal contenuto del file `changelog` e dal file `.dsc`.

  Quando si lavora sul pacchetto, potrebbero cambiare il funzionamento del programma, o potrebbero venire introdotte nuove funzionalità. Chi scaricherà il pacchetto, potrà controllare questo file per vedere velocemente quali sono i cambiamenti. I programmi di manutenzione dell'archivio Debian invieranno anche i contenuti di questo file alla mailing list debian-devel-changes-@lists.debian.org.

I file `gentoo_0.9.12-1.dsc` e `gentoo_0.9.12-1_i386.changes` devono essere firmati usando il comando debsign con la propria chiave privata GPG presente nella directory `~/.gnupg/`, prima di caricarli nell'archivio FTP Debian. La firma GPG è la prova che questi file sono veramente stati generati da te, utilizzando la chiave GPG pubblica.

Il comando debsign può essere eseguito per firmare con l'ID della chiave GPG specificata, nel file `~/.devscripts`, come seguie (utile in caso di sponsoring di pacchetti):

    DEBSIGN_KEYID=Your_GPG_keyID

Le lunghe stringhe di numeri nei file `.dsc` e `.changes` sono codici di controllo SHA1/SHA256 per i file menzionati. Chi scarica questi file, può controllarli con sha1sum(1), o sha256sum(1) e se i numeri non corrispondessero saprebbe che il file relativo è corrotto, o è stato alterato.

## 6.2. Auto-costruzione

Debian supporta molti port tramite la autobuilder network, su cui sono in esecuzione i demoni di buildd su molti computer con architetture differenti. Anche se non sarà necessario fare questo da soli, si dovrebbe essere consapevoli di quello che succederà ai pacchetti. Si vedrà, in maniera non approfondita, come i pacchetti vengono ricostruiti per architetture differenti. [64]

I pacchetti con `Architecture: any`, verranno ricostruiti dal sistema di auto-costruzione. Ci si assicuri di avere installato

- il pacchetto `build-essential`, e

- i pacchetti elencati nel campo `Build-Depends` (vedere Sezione 4.1, «`control`»).

Dopo si può eseguire il comando seguente nella directory dei sorgenti:

    $ dpkg-buildpackage -B

Questo comando creerà i pacchetti binari e sorgenti al posto vostro. Eseguirà le seguenti operazioni:

- pulirà l'albero dei sorgenti (`debian/rules clean`)

- costruirà il programma (`debian/rules build`)

- costruirà il pacchetto binario per una specifica architettura (`fakeroot debian/rules binary-arch`)

- firmerà il file sorgente `.dsc` file, usando gpg

- creerà e firmerà il file di upload `.changes` file, usando dpkg-genchanges e gpg

È questo il motivo per il quale si vede il proprio pacchetto per altre architetture.

Anche se i pacchetti sono elencati nel campo `Build-Depends-Indep`, per la normale creazione del pacchetto, devono comunque essere installati (vedere Sezione 6.1, «(ri)Creazione completa»), invece per il sistema di auto-costruzione non è necessario installarli dato che costruisce solamente pacchetti binari per una specifica architettura. [65] Questa distinzione tra la normale pacchettizzazione e il sistema di auto-costruzione determina se i pacchetti richiesti devono essere registrati nei campi `Build-Depends` o `Build-Depends-Indep` nel file `debian/control` (vedere Sezione 4.1, «`control`»).

## 6.3. Il comando debuild

È possibile automatizzare ulteriormente il processo di creazione del pacchetto, eseguito con il comando dpkg-buildpackage, utilizzando il comando debuild. Vedere debuild(1).

Il comando debuild esegue il comando lintian per effettuare un controllo statico dopo la creazione del pacchetto Debian. Il comando lintian può essere personalizzato come segue, nel file `~/.devscripts`:

    DEBUILD_DPKG_BUILDPACKAGE_OPTS="-us -uc -I -i"
    DEBUILD_LINTIAN_OPTS="-i -I --show-overrides"

Si possono ripulire i sorgenti e ricreare il pacchetto da un account utente, semplicemente con:

    $ debuild

È possibile ripulire l'albero dei sorgenti semplicemente con:

    $ debuild -- clean

## 6.4. Il pacchetto `pbuilder`

Il pacchetto `pbuilder` è molto utile per verificare le dipendenze di creazione del pacchetto da un ambiente (chroot) di compilazione sano e minimale. [66] Questo assicura di compilare i sorgenti in maniera pulita, usando la distribuzione `sid` un compilatore automatico (auto-builder) per differenti architetture ed evita i bug FTBFS (Fails To Build From Source) di severità seria, che sono sempre di categoria RC (Critici per il Rilascio). [67]

Si configuri il pacchetto `pbuilder` come segue:

- impostare il permesso di scrittura per l'utente alla directory `/var/cache/pbuilder/result`.

- creare una directory, ad es. ``/var/cache/pbuilder/hooks``, con i permessi di scrittura per l'utente per potergli inserire degli script di hook.

- configurare il file `~/.pbuilderrc` o `/etc/pbuilderrc` in modo che includa le seguenti righe.

      AUTO_DEBSIGN=${AUTO_DEBSIGN:-no}
      HOOKDIR=/var/cache/pbuilder/hooks

Si avvii `pbuilder` per costruire l'ambiente chroot locale, come segue:

    $ sudo pbuilder create

Se si hanno già i pacchetti sorgenti, eseguire i seguenti comandi nella directory in cui si trovano i file ``foo`.orig.tar.gz`, ``foo`.debian.tar.gz`, e ``foo`.dsc` per aggiornare l'ambiente chroot di `pbuilder` e per costruirci dentro il pacchetto binario:

    $ sudo pbuilder --update
    $ sudo pbuilder --build foo_version.dsc

Il nuovo pacchetto, senza firme GPG, sarà creato nella directory `/var/cache/pbuilder/result/` e non sarà assegnato all'utente root.

Le firme GPG sui file `.dsc` `.changes` possono essere generate come segue:

    $ cd /var/cache/pbuilder/result/
    $ debsign foo_version_arch.changes

Se si ha l'albero dei sorgenti aggiornato, ma non si sono generati i rispettivi pacchetti sorgenti, eseguire i seguenti comandi nella directory dei sorgenti in cui si trova il file `debian`:

    $ sudo pbuilder --update
    $ pdebuild

È possibile accedere all'ambiente chroot con il comando `pbuilder --login --save-after-login` e configurarlo come si vuole. Questo ambiente può essere salvato, semplicemente uscendo dalla shell con `^D` (Control-D).

L'ultima versione del programma lintian può essere eseguita nell'ambiente `chroot`, usando gli script di hook ``/var/cache/pbuilder/hooks`/B90lintian`, configurati come segue: [68]

    #!/bin/sh
    set -e
    install_packages() {
            apt-get -y --allow-downgrades install "$@"
            }
    install_packages lintian
    echo "+++ lintian output +++"
    su -c "lintian -i -I --show-overrides /tmp/buildd/*.changes" - pbuilder
    # use this version if you don't want lintian to fail the build
    #su -c "lintian -i -I --show-overrides /tmp/buildd/*.changes; :" - pbuilder
    echo "+++ end of lintian output +++"

È necessario avere accesso all'ultima versione di `sid` per poter costruire correttamente i pacchetti per `sid`. In pratica `sid` potrebbe avere dei problemi che rendono poco consigliabile migrare l'intero sistema. In questo caso il pacchetto `pbuilder` può essere molto di aiuto.

Potrebbe essere necessario aggiornare i pacchetti `stable` dopo il loro rilascio per `stable-proposed-updates`, `stable/updates`, ecc. [69] Per questa ragione se si sta utilizzando un sistema `sid` non è una buona scusa per non aggiornarli tempestivamente. Il pacchetto `pbuilder` aiuta ad accedere agli ambienti di quasi tutte le distribuzioni derivate da Debian con la stessa architettura di CPU.

Vedere http://www.netfort.gr.jp/~dancer/software/pbuilder.html, pdebuild(1), pbuilderrc(5), e pbuilder(8).

## 6.5. Il comando git-buildpackage ed altri simili

Se l'autore originale utilizza un sistema di controllo di versione (VCS) [70] per gestire il proprio codice, si dovrebbe prendere in considerazione di usarlo. Questo rende molto più semplice la fusione e la raccolta di patch dai sorgenti originali. Ci sono diversi pacchetti di script adatti alla costruzione di pacchetti Debian per ogni sistema VCS.

- `git-buildpackage`: una suite per aiutare con i pacchetti Debian nei repository Git.

- `svn-buildpackage`: programmi di supporto per mantenere i pacchetti Debian con Subversion.

- `cvs-buildpackage`: una serie di script per i pacchetti Debian per gli alberi di sorgenti sotto CVS.

L'utilizzo di `git-buildpackage` sta diventando molto popolare per gli sviluppatori Debian,questo permette di gestire i pacchetti Debian con il server Git su alioth.debian.org. [71] Questo pacchetto offre molti comandi che automatizzano le procedure di pacchettizzazione:

- gbp-import-dsc(1): import a previous Debian package to a Git repository.

- gbp-import-orig(1): import a new upstream tar to a Git repository.

- gbp-dch(1): generate the Debian changelog from Git commit messages.

- git-buildpackage(1): costruisce i pacchetti Debian da un repository Git.

- git-pbuilder(1): costruisce i pacchetti Debian da un repository Git, utilizzando pbuilder/cowbuilder.

Questi comandi utilizzano 3 "branch" per tenere traccia dell'attività sulla pacchettizzazione:

- `main` per l'albero dei sorgenti dei pacchetti Debian.

- `upstream` per l'albero dei sorgenti originali.

- `pristine-tar` per i tarball dei sorgenti originali generati dall'opzione `--pristine-tar`.[72]

È possibile configurare `git-buildpackage` utilizzando il file `~/.gbp.conf`. Vedere gbp.conf(5). [73]

## 6.6. Ricostruzione veloce

Con un pacchetto di grandi dimensioni, si potrebbe non voler ricostruire tutto da zero, ogni volta che si modifica un dettaglio in `debian/rules`. Per effettuare delle prove, si può creare un file `.deb`, senza ricompilare i sorgenti originali, come segue: [74]:

    $ fakeroot debian/rules binary

Oppure, semplicemente controllando se si costruisce o no:

    $ fakeroot debian/rules build

Una volta completati i vari aggiustamenti, bisogna ricordarsi di ricostruire il pacchetto usando la giusta procedura. Si potrebbe non essere in grado di caricare il pacchetto correttamente se si prova con dei file `.deb` creati in questo modo.

## 6.7. Struttura gerarchica del comando

Ecco un breve riassunto di come molti comandi per creare i pacchetti si incastrano nella gerarchia di comando. Ci sono molti modi per fare la stessa cosa.

- `debian/rules` = script responsabile della costruzione del pacchetto

- dpkg-buildpackage = il cuore dello strumento di costruzione del pacchetto

- debuild = dpkg-buildpackage + lintian (creare il pacchetto utilizzando un ambiente con le variabili controllate)

- pbuilder = il cuore dello strumento chroot dell'ambiente Debian

- pdebuild = pbuilder + dpkg-buildpackage (costruito in chroot)

- cowbuilder = velocizza l'esecuzione di pbuilder

- git-pbuilder = una sintassi a linea di comando facilitata per pdebuild (usato da gbp buildpackage)

- gbp = gestisce il sorgente Debian utilizzando un repository git

- gbp buildpackage = pbuilder + dpkg-buildpackage + gbp

Sebbene l'uso di comandi di alto livello come gbp buildpackage e pbuilder assicura l'ambiente ideale per la costruzione del pacchetto, è essenziale comprendere come i comandi di basso livello `debian/rules` e dpkg-buildpackage vengono richiamati da loro.

[62] Questa chiave GPG deve essere firmata da uno sviluppatore Debian per collegarsi alla rete di fiducia e bisogna essere registrati al portachiavi Debian. In questo modo i pacchetti caricati potranno essere accettati ed inseriti negli archivi Debian. Vedere Creare una nuova chiave GPG e Debian Wiki on Keysigning.

[63] È possibile evitare di applicare la patch quilt, nel formato sorgente `3.0 (quilt)`, aggiungendo il parametro `--skip-patches` al comando di estrazione. In alternativa, è possibile eseguire `dquilt pop -a` dopo le normali operazioni.

[64] L'attuale sistema di auto-costruzione è molto più complicato di come è qui documentato. Tali dettagli esulano dallo scopo del documento.

[65] Diversamente dal pacchetto `pbuilder`, l'ambiente chroot sotto il pacchetto `sbuild`, usato dal sistema di auto-costruzione, non forza la creazione di un sistema minimale, e potrebbe lasciare installati molti pacchetti.

[66] `pbuilder` è ancora in evoluzione, si dovrebbe controllare l'attuale configurazione consultando la documentazione ufficiale più recente.

[67] Vedere http://buildd.debian.org/ per maggiori informazioni sull'auto-costruzione dei pacchetti Debian.

[68] Ciò presuppone il settaggio `HOOKDIR=/var/cache/pbuilder/hooks`. È possibile trovare numerosi esempi di script di hook, nella directory `/usr/share/doc/pbuilder/examples`.

[69] Ci sono alcune restrizioni per tali aggiornamenti del pacchetto `stable`.

[70] Vedere Version control systems per più informazioni.

[71] Debian wiki Alioth spiega come usare il servizio alioth.debian.org.

[72] L'opzione `--pristine-tar` esegue il comando pristine-tar che può rigenerare un copia esatta del tarball dei sorgenti originali, utilizzando solo un piccolo file binario delta e i contenuti del tarball, che normalmente sono conservati nel branch `upstream` del VCS.

[73] Ecco alcune risorse web, per gli utenti esperti.

- Creare pacchetti Debian Packages con git-buildpackage (`/usr/share/doc/git-buildpackage/manual-html/gbp.html`)

- debian packages in git

- Using Git for Debian Packaging

- git-dpm: Debian packages in Git manager

[74] Le variabili d'ambiente, che sono normalmente impostate con dei valori corretti, non sono utilizzati in questa modalità. Mai creare dei pacchetti, che poi andranno caricati, utilizzando il metodo veloce.

Capitolo 5. Altri file nella directory `debian` |  | Capitolo 7. Controllare il pacchetto per errori