Chapitre 6. Construction du paquet

# Chapitre 6. Construction du paquet

La réécriture de ce tutoriel avec des contenus à jour et des exemples pratiques supplémentaires est disponible sur Guide du responsable Debian. Veuillez utiliser ce nouveau tutoriel comme document principal.

Tout devrait maintenant être prêt pour construire le paquet.

## 6.1. Reconstruction complète

Pour réaliser correctement la reconstruction complète d'un paquet, doivent être installés :

- le paquet `build-essential` ;

- les paquets énumérés dans le champ `Build-Depends` (consultez Section 4.1, « `control` ») ;

- les paquets énumérés dans le champ `Build-Depends-indep` (consultez Section 4.1, « `control` »).

Ensuite, exécutez la commande suivante dans le répertoire des sources :

    $ dpkg-buildpackage -us -uc

Cela fera tout le nécessaire pour créer entièrement les paquets binaires et source à votre place :

- nettoyage de l'arbre des sources (`debian/rules clean`) ;

- construction du paquet source (`dpkg-source -b`) ;

- construction du programme (`debian/rules build`) ;

- construction des paquets binaires (`fakeroot debian/rules binary`) ;

- création du fichier `.dsc` ;

- création du fichier `.changes`, en utilisant dpkg-genchanges.

Si le résultat de la construction est satisfaisant, signez les fichiers `.dsc` et `.changes` avec votre clef privée GPG avec la commande debsign. Vous devez entrer votre phrase secrète deux fois. [62]

Pour un paquet Debian non natif, par exemple `gentoo`, vous verrez les fichiers suivants dans le répertoire parent (`~/gentoo`) après la construction des paquets :

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

  C'est le code source amont d'origine, simplement renommé pour être conforme aux normes Debian. Il a été créé au début avec la commande `dh_make -f ../gentoo-0.9.12.tar.gz`.

- `gentoo_0.9.12-1.dsc`

  c'est un résumé du contenu du code source. Il est créé à partir du fichier `control`, et est utilisé pour décompresser les sources avec dpkg-source(1).

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

  Cette archive compressée contient le répertoire `debian`. Tous les ajouts et modifications au code source d'origine sont conservés en tant que correctif quilt dans `debian/patches`.

  Si quelqu'un d'autre veut recréer le paquet depuis le début, il peut facilement le faire en utilisant ces trois fichiers. La procédure d'extraction est facile : copier simplement ces trois fichiers quelque part et exécuter `dpkg-source -x gentoo_0.9.12-1.dsc`.[63]

- `gentoo_0.9.12-1_i386.deb`

  c'est le paquet binaire terminé. Vous pouvez utiliser dpkg pour l'installer ou le retirer comme n'importe quel autre paquet.

- `gentoo_0.9.12-1_i386.changes`

  Ce fichier décrit toutes les modifications effectuées dans la révision actuelle du paquet, et est utilisé par les programmes de maintenance des archives FTP Debian pour y installer les paquets binaires et sources. Il est partiellement créé à partir des fichiers `changelog` et `.dsc`.

  Au fur et à mesure que vous travaillez sur le paquet, son comportement va évoluer et de nouvelles fonctionnalités seront ajoutées. Les gens qui téléchargent votre paquet peuvent lire ce fichier et voir rapidement ce qui a changé. Les programmes de maintenance des archives Debian vont aussi poster le contenu de ce fichier sur la liste de diffusion debian-devel-changes@lists.debian.org.

Les fichiers `gentoo_0.9.12-1.dsc` et `gentoo_0.9.12-1_i386.changes` doivent être signés en utilisant la commande debsign avec votre clef privée GPG du répertoire `~/.gnupg/`, avant de les téléverser dans l’archive FTP de Debian. La signature GPG fournit la preuve que ce sont vraiment vos fichiers par l’utilisation de votre clef publique GPG.

La commande debsign peut être utilisée pour signer avec votre identifiant de clef secrète GPG (utile pour les paquets parrainés) dans le fichier `~/.devscripts` comme suit :

    DEBSIGN_KEYID=Votre_ID_de_clef_GPG

Les longues chaînes de chiffres dans les fichiers `.dsc` et `.changes` sont les sommes SHA1 et SHA256 des fichiers indiqués. Les personnes téléchargeant vos fichiers peuvent les vérifier avec sha1sum(1) ou sha256sum(1), et si les fichiers ne correspondent pas, elles sauront que le fichier a été corrompu ou falsifié.

## 6.2. Serveurs d'empaquetage automatique (« autobuilder »)

Debian gère de nombreux portages avec le réseau de serveurs d'empaquetage automatique faisant fonctionner des démons buildd sur de nombreux ordinateurs d'architectures différentes. Même si vous n'avez pas besoin de le faire vous-même, vous devriez être au courant de ce qui va arriver à vos paquets. La suite présente brièvement comment les paquets sont reconstruits sur plusieurs architectures. [64]

Les paquets `Architecture: any` sont reconstruits par les serveurs d'empaquetage automatique. Seront installés :

- le paquet `build-essential` ;

- les paquets énumérés dans le champ `Build-Depends`, (consultez Section 4.1, « `control` »).

Ensuite, la commande suivante est exécutée dans le répertoire des sources :

    $ dpkg-buildpackage -B

Cela fera tout le nécessaire pour créer entièrement les paquets binaires dépendant de l'architecture sur l'architecture concernée :

- nettoyage de l'arbre des sources (`debian/rules clean`) ;

- construction du programme (`debian/rules build`) ;

- construction des paquets binaires dépendants de l'architecture (`fakeroot debian/rules binary-arch`) ;

- signature du fichier source `.dsc`, en utilisant gpg ;

- création et signature du fichier de téléchargement `.changes`, en utilisant dpkg-genchanges et gpg.

C'est pourquoi votre paquet est disponible sur plusieurs architectures.

Bien qu'il soit nécessaire d'installer les paquets énumérés dans le champ `Build-Depends-Indep` pour l'empaquetage normal (consultez Section 6.1, « Reconstruction complète »), il n'est pas nécessaire de les installer sur le serveur d'empaquetage automatique puisqu'il ne construit que les paquets binaires dépendants de l'architecture. [65] Cette distinction entre l'empaquetage normal et celui des serveurs d'empaquetage automatique permet de déterminer si les paquets doivent être énumérés dans le champ `Build-Depends` ou `Build-Depends-Indep` du fichier `debian/control` (consultez Section 4.1, « `control` »).

## 6.3. Commande debuild

Vous pouvez automatiser le processus de construction en utilisant la commande dpkg-buildpackage et empaqueter ensuite avec la commande debuild, consultez debuild(1).

La commande debuild exécute la commande lintian pour une analyse statique après la construction du paquet Debian. La commande lintian peut être personnalisée dans `~/.devscripts` avec ce qui suit :

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

Le nettoyage des sources et la reconstruction du paquet avec un compte utilisateur est aussi simple que :

    $ debuild

Le nettoyage de l'arborescence des sources est aussi simple que :

    $ debuild -- clean

## 6.4. Paquet `pbuilder`

Pour un environnement de construction propre (chroot) permettant de vérifier les dépendances de construction, `pbuilder` est très utile. [66] Cela garantit une construction propre des sources en construction automatique sous `sid` pour différentes architectures et évite une erreur sérieuse FTBFS (« Fails To Build From Source » pour les échecs de construction à partir du paquet source), qui est toujours en catégorie RC (« Release Critical », bloquant la publication). [67]

Le paquet `pbuilder` est personnalisable de la manière suivante :

- configuration du répertoire `/var/cache/pbuilder/result` accessible en écriture pour l'utilisateur ;

- création d'un répertoire, par exemple ``/var/cache/pbuilder/hooks``, accessible en écriture pour l'utilisateur pour y placer ses scripts hook ;

- configuration de `~/.pbuilderrc` ou `/etc/pbuilderrc` pour intégrer ce qui suit :

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

D'abord, le système chroot local de `pbuilder` doit être initialisé :

    $ sudo pbuilder create

Si vous possédez déjà le paquet source terminé, exécutez les commandes suivantes dans le répertoire contenant les fichiers ``toto`.orig.tar.gz`, ``toto`.debian.tar.gz`, et ``toto`.dsc` pour mettre à jour le système chroot de `pbuilder` et y construire les paquets binaires :

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

Les paquets nouvellement créés sans signatures GPG sont accessibles en `/var/cache/pbuilder/result/` et n'appartiennent pas au superutilisateur.

Les signatures GPG des fichiers `.dsc` et `.changes` peuvent être créées avec :

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

Si vous possédez une arborescence des sources à jour, mais n'avez pas créé le paquet source correspondant, exécutez plutôt les commandes suivantes dans le répertoire des sources ayant un répertoire `debian` :

    $ sudo pbuilder --update
    $ pdebuild

Vous pouvez vous connecter à l'environnement chroot avec la commande `pbuilder --login --save-after-login` et le configurer à votre convenance. Cet environnement peut être sauvegardé en quittant l'invite de commande avec `^D` (Contrôle-D).

La dernière version de la commande lintian peut être exécutée dans l'environnement `chroot` en utilisant le script hook ``/var/cache/pbuilder/hooks`/B90lintian` configuré comme suit : [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
    # utilisez ceci si vous ne voulez pas que lintian arrête la construction
    #su -c "lintian -i -I --show-overrides /tmp/buildd/*.changes; :" - pbuilder
    echo "+++ end of lintian output +++"

Un environnement `sid` à jour est nécessaire pour construire correctement les paquets destinés à `sid`. En pratique, `sid` peut parfois être victime de problèmes qui peuvent rendre non souhaitable la migration de votre système complet. Le paquet `pbuilder` peut vous aider à faire face à ce genre de situation.

Vous pouvez avoir besoin de mettre à jour vos paquets `stable` après sa publication à destination de `stable-proposed-updates`, `stable/updates`, etc. [69] Dans ces cas-là, le fait d'utiliser `sid` est une mauvaise excuse pour ne pas les mettre à jour au plus tôt. Le paquet `pbuilder` vous permet d'accéder à la plupart des distributions dérivées de Debian pour la même architecture.

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

## 6.5. Commandes git-buildpackage et similaires

Si les développeurs amont utilisent un système de gestion de versions (VCS) [70] pour maintenir leur code source, vous devriez envisager aussi de l'utiliser. Cela rend la fusion et la sélection (« cherry-picking ») des correctifs amont plus faciles. De nombreux paquets de scripts d'enrobage sont disponibles pour la construction de paquets Debian pour chaque système de gestion de versions :

- `git-buildpackage` : assistants pour les paquets Debian gérés dans des dépôts Git ;

- `svn-buildpackage` : assistants pour la maintenance de paquets Debian avec Subversion ;

- `cvs-buildpackage` : scripts pour paquets Debian pour les arbres de sources CVS.

L'utilisation de `git-buildpackage` devient assez populaire parmi les développeurs Debian pour gérer les paquets Debian avec le serveur Git sur alioth.debian.org. [71] Ce paquet fournit plusieurs commandes pour automatiser les activités d'empaquetage :

- 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) : construire des paquets Debian à partir d'un dépôt Git ;

- git-pbuilder() : construire des paquets Debian à partir d'un dépôt Git en utilisant pbuilder ou cowbuilder.

Ces commandes utilisent trois branches pour suivre les activités d'empaquetage :

- `main` pour l'arborescence source de paquet Debian ;

- `upstream` pour l'arborescence source amont ;

- `pristine-tar` pour l'archive amont générée par l'option `--pristine-tar`.[72]

`git-buildpackage` peut être configuré dans `~/.gbp.conf`. Consultez gbp.conf(5). [73]

## 6.6. Reconstruction rapide

Avec un paquet imposant, vous ne voudrez sans doute pas reconstruire depuis le début chaque fois que vous faites une petite modification à `debian/rules`. Pour tester, vous pouvez faire un fichier `.deb` sans reconstruire les sources amont comme ceci [74] :

    $ fakeroot debian/rules binary

Ou faites simplement comme suit pour voir s'il y a construction ou non :

    $ fakeroot debian/rules build

Une fois terminés vos ajustements, souvenez-vous de reconstruire en suivant la procédure correcte ci-dessus. Vous pouvez être incapable d'envoyer proprement si vous essayez d'envoyer des fichiers `.deb` construits de cette façon.

## 6.7. Hiérarchie des commandes

Voici un résumé sommaire de la façon dont beaucoup de commandes s’assemblent de manière hiérarchique. Il y a plusieurs manières de faire la même chose :

- `debian/rules` = script du mainteneur pour la construction du paquet ;

- dpkg-buildpackage = partie principale de l’outil de construction de paquet ;

- debuild = dpkg-buildpackage + lintian (construction avec des variables d’environnement vérifiées) ;

- pbuilder = partie principale de l’outil pour l’environnement chroot de Debian ;

- pdebuild = pbuilder + dpkg-buildpackage (construction dans le chroot) ;

- cowbuilder = accélération de l’exécution de pbuilder ;

- git-pbuilder = syntaxe d’utilisation aisée de ligne de commande pour pdebuild (utilisée par gbp buildpackage) ;

- gbp = gestion des sources Debian dans le dépôt git ;

- gbp buildpackage = pbuilder + dpkg-buildpackage + gbp.

Bien que les commandes de haut niveau telles que gbp buildpackage et pbuilder garantissent un environnement de construction de paquet parfait, il est essentiel de comprendre comment les commandes de bas niveau, telles que `debian/rules` et dpkg-buildpackage, sont exécutées en dessous.

[62] Cette clef GPG doit être signée par un développeur Debian pour être connectée au réseau de confiance et doit être enregistrée dans le trousseau Debian. Cela permet à vos paquets d'être acceptés dans l'archive Debian. Consultez la page de création d'une nouvelle clef GPG et le wiki Debian à propos de la signature de clef.

[63] Il est possible de ne pas appliquer les correctifs quilt du format source `3.0 (quilt)` à la fin de l'extraction avec l'option `--skip-patches`. Sinon, il est aussi possible d'exécuter `dquilt pop -a` après l'extraction normale.

[64] Le véritable réseau de serveurs d'empaquetage automatique a un fonctionnement autrement plus compliqué que celui présenté ici. De tels détails sortent du cadre de ce document.

[65] Contrairement à celui du paquet `pbuilder`, l'environnement chroot du paquet `sbuild` utilisé par les serveurs d'empaquetage automatique n'est pas forcément minimal et plusieurs paquets peuvent rester installés.

[66] Comme le paquet `pbuilder` est en constante évolution, vous devriez vérifier les possibilités réelles de la configuration en consultant la dernière documentation officielle.

[67] Consultez http://buildd.debian.org/ pour obtenir plus de renseignements sur le service de construction automatique de paquets Debian.

[68] Cela suppose que `HOOKDIR=/var/cache/pbuilder/hooks` est déjà configuré. De nombreux exemples de scripts hook sont disponibles dans le répertoire `/usr/share/doc/pbuilder/examples`.

[69] Il existe des restrictions pour de telles mises à jour de paquet `stable`.

[70] Consultez Systèmes de contrôle de versions pour obtenir plus de renseignements.

[71] Le wiki Debian sur Alioth documente la façon d'utiliser le service alioth.debian.org.

[72] L'option `--pristine-tar` invoque la commande pristine-tar qui peut générer une copie exacte de l'archive amont d'origine en n'utilisant qu'un petit fichier binaire de delta et le contenu de l'archive amont, qui est normalement gardé dans une branche `upstream` du système de gestion de versions.

[73] Voici quelques ressources disponibles sur la toile pour les utilisateurs avancés :

- Construction de paquets Debian avec git-buildpackage (`/usr/share/doc/git-buildpackage/manual-html/gbp.html`) ;

- Paquets Debian avec Git ;

- Utilisation de Git pour l'empaquetage Debian ;

- git-dpm : paquets Debian dans le gestionnaire Git ;

[74] Les variables d'environnement qui devraient normalement être configurées correctement à cette étape ne sont pas configurées par cette méthode. Ne créez jamais de vrais paquets pour l'envoi avec cette méthode rapide.

Chapitre 5. Autres fichiers dans le répertoire `debian` |  | Chapitre 7. Contrôle des erreurs du paquet