Capitolo 6. Costruzione del pacchetto

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

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:

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:

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.

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

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:

È 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»).

È 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

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:

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).

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.

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:

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

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

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.

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.