Capitolo 6. Costruzione del pacchetto

Indice

6.1. (ri)Creazione completa
6.2. Auto-costruzione
6.3. Il comando debuild
6.4. Il pacchetto pbuilder
6.5. Il comando git-buildpackage ed altri simili
6.6. Ricostruzione veloce
6.7. Struttura gerarchica del comando

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

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:

  • 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 [email protected].

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:

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

È 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:

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

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]

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.



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

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