Création de paquets avec ArchLinux

Introduction du cours

Vous avez envie de créer le paquet ArchLinux pour votre super jeu en 3D ou encore pour votre éditeur de texte révolutionnaire mais vous ne savez pas par où commencer ?

Pour suivre ce tutoriel, il vous faut évidemment une distribution ArchLinux fonctionnelle. Si vous voulez installer ce système, vous pouvez vous référer à la page « Installation de base » du wiki français. Il faut aussi une base en bash (variables, tableaux, conditions et fonctions sont utilisés dans ce tutoriel) ainsi qu'une connaissance des commandes courantes.

Si c'est bon, suivez le guide...

PKGBUILD ou la base du paquet

Tout d'abord, sachez que PKGBUILD est un simple fichier texte qui va expliquer comment se déroule la création du paquet.
Nous allons donc voir sa syntaxe et faire une approche de paquet.

Pour comprendre la syntaxe de ce fichier, je vous propose un petit PKGBUILD classique pour un programme fictif nommé Palne :

# Maintainer: Adrien Perkele <perkele@domain.tld> # Contributor: Adrien Perkele <perkele@domain.tld> pkgname=palne pkgver=0.99_10 pkgrel=1 pkgdesc="Palne, le jeu super cool de Perkele" arch=(any) url="http://www.palne.net" license=('BSD') groups= provides= depends=('scengine>=1.2') optdepends=('unelib: Pour rajouter une fonctionnalité au programme !') makedepends= conflicts=('kipalne') replaces=('palneuh') backup=('etc/palne/palne.conf') install= source=(http://www.palne.net/download/$pkgname-$pkgver.tar.gz) md5sums=('40972633cea6c8d38ff26dade3eec51e') build() { cd $srcdir/$pkgname-$pkgver ./configure --prefix=/usr make || return 1 make prefix=$pkgdir/usr install }

Évidemment, toutes ces variables ne vous disent peut-être pas grand-chose, je vous propose donc ce petit tableau :

Nom

Description

# Maintainer

La personne qui se charge officiellement de la maintenance du paquet (format Nom <mail@domain.tld>)

# Contributor

La personne qui est à l'origine du paquet (même format)

pkgname

Nom du paquet

pkgver

Version du programme ( chiffres et lettres uniquement, pour séparer on utilise des underscores (_) ).

pkgrel

Valeur spécifique à ArchLinux, elle correspond à la version du paquet (pour chaque version d'un PKGBUILD d'un même programme de la même version, on met une valeur différente, en commençant par 1). Elle gère entre autres les paquets périmés.

pkgdesc

Courte description du contenu du paquet qui sera affichée dans les détails.

arch

L'architecture où la compilation du programme est compatible (i686 ou x86_64 ou any pour les deux)

url

Site du programme

license

Licence du programme (lire la partie « Le problème des licences » pour les valeurs)

groups

Si le paquet appartient à un groupe de paquets, on le précise (exemple kdebase appartient au groupe kde)

provides

Si notre paquet fournit un autre logiciel, on le précise

depends

Les dépendances du programme (lire la partie « Les dépendances » pour savoir comment ça marche)

optdepends

Paquet optionnel qui rajoute en général des fonctionnalités au programme (exemple, pacman-color rajoute de la couleur dans pacman).

makedepends

Ce sont aussi des dépendances, mais celles que la compilation nécessite (pareil, voir la partie « Les dépendances »)

conflicts

Les paquets qui empêchent le fonctionnement de notre programme

replaces

Précise les paquets que notre programme remplace (exemple, ancienne version du programme qui porte un autre nom)

backup

Les fichiers qui seront sauvegardés à la désinstallation

install

Précise un fichier d'installation (voir la partie « Les fichiers d'installation »)

source

Le lien de l'archive contenant les sources

md5sums

Permet de vérifier l'intégralité de l'archive en fournissant son empreinte MD5

build()

Fonction qui nous permettra de préparer le paquet (compilation ainsi que placement dans le paquet final)

Les dépendances

Pour la variable depends, on prend un tableau avec la liste des dépendances sous la forme « '[nom du paquet archlinux]' ». On peut aussi préciser une version avec un comparatif (qui je rappelle sont =, >, <,<= ou encore >=) suivi d'un numéro de version (par exemple « 'python>=2.6' »).

Le problème des licences

La variable licence est assez particulière, en effet il faut respecter une syntaxe et ne pas balancer le nom d'une licence comme ça.
Il y a plusieurs cas selon les licences, je vais essayer de vous les détailler un maximum.
Tout d'abord, vérifiez si un dossier du nom de la licence existe dans /usr/share/licenses/common/ :

• Si votre licence (elle est « common ») s'y trouve, il suffit d'écrire le nom du répertoire dans la variable license (exemple: license=('GPL')) ;

• Si votre licence est MIT, BSD, zlib/libpng ou encore Python, vous devrez créer un fichier nommé généralement COPYING (le nom n'est pas important) contenant le texte de la licence dans /usr/share/licenses/$pkgname. Vous verrez comment faire cela dans la partie sur la fonction build(). Pour l'utiliser, il suffira de faire comme pour les licences common, un exemple se trouve dans mon fichier PKGBUILD ;

• Dans le cas d'une licence personnelle, vous allez aussi créer votre fichier COPYING. Quant à l'utilisation dans le PKGBUILD, vous allez utiliser la syntaxe « license=('custom:Nom de la licence') ;

• Enfin, dernier cas, si votre paquet est couvert par plusieurs licences, vous aurez remarqué que license est un tableau : chaque valeur est une licence (exemple : license=('GPL' 'custom:crave' 'BSD')).

La variable md5sums

Un petit mot sur le md5sums : pour le calculer, il suffit d'utiliser la commande md5sum ainsi :

md5sum monprogramme-1.1_1.tar.gz | cut -d ' ' -f 1

C'est le résultat de cette commande que vous allez mettre dans la variable md5sums.

La fonction build()

Maintenant, nous rentrons dans le vif du sujet. Jusqu'ici, nous avons fait de la théorie sur la création et nous savons récupérer les sources, vérifier qu'elles sont complètes, mais nous ne savons toujours pas créer le paquet !
C'est la fonction build() qui va se charger de cette tâche.

En général, l'ordre des commandes dans cette fonction est celui-ci :

Fonction build     On se place dans le répertoire contenant les sources téléchargées     On compile les sources      On place dans le répertoire qui va être le paquet tout ce qu'il nous faudra Fin de la fonction

Il faut savoir qu'un paquet est une simple archive qui contient l'architecture du système. Le gestionnaire s'occupera donc ainsi (en partie) de décompresser l'archive à la racine.
Pendant la création de notre fonction, nous allons traiter un dossier nommé pkg, qui sera compressé à l'exécution du PKGBUILD.

Comme exemple, nous allons maintenant imaginer que notre archive tar.gz téléchargée contient ceci :

Archive tar.gz ---- bin/ ---- doc/ -------- palne.6.gz -------- index.html ---- src/ -------- main.c -------- fonctions.c -------- fonctions.h ---- data/ -------- COPYING -------- images/ ------------ icone.png ------------ splash.png ------------ gagne.png ------------ perdu.png -------- conf/ ------------ palne.cfg ---- Makefile

Nous allons maintenant créer la fonction build() qui va :

• compiler les sources ;

• mettre le man dans le répertoire qui correspond ;

• mettre la doc dans le répertoire qui correspond ;

• mettre l'exécutable dans /usr/bin ;

• mettre la configuration dans /etc ;

• placer la licence dans /usr/share/licenses/ ;

• et enfin mettre les images dans /usr/share/.

Tout d'abord, on se place dans le répertoire des sources :

build() { cd $srcdir/$pkgname

La variable srcdir contient le répertoire où l'archive a été décompressée.
Attention néanmoins, les fichiers décompressés sont dans un répertoire du même nom que le paquet.

Nous allons donc maintenant compiler les sources de notre programme en exécutant simplement le Makefile :

make || return 1

Comme vous le constatez, ma commande de compilation est suivie d'un || return 1 : cela permet de dire que si la commande a échoué, on arrête la création du paquet.
Il faudra placer ceci après chaque commande importante pour le paquet.

Passons maintenant à la création de l'architecture du paquet :

mkdir -p $pkgdir/usr/bin/ mkdir -p $pkgdir/usr/share/palne/ mkdir -p $pkgdir/usr/share/doc/palne/ mkdir -p $pkgdir/usr/man/man6/ mkdir -p $pkgdir/etc/palne/ mkdir -p $pkgdir/usr/share/licenses/palne/

À noter que la variable pkgdir correspond au dossier pkg dont je vous avais parlé plus tôt.
On va maintenant pouvoir passer à la copie des fichiers :

cp bin/palne $pkgdir/usr/bin/ chmod +x $pkgdir/usr/bin cp doc/palne.6.gz $pkgdir/usr/man/man6/ cp doc/index.html $pkgdir/usr/share/doc/palne/ cp -r data/images/ $pkgdir/usr/share/palne/images/ cp data/conf/palne.cfg $pkgdir/etc/palne/ cp data/COPYING $pkgdir/usr/share/licenses/palne/

À noter que le chmod est obligatoire si l'on veut pouvoir exécuter le programme.

Et bonne nouvelle, nous avons fini notre fonction build() !
Néanmoins, il ne faut pas oublier de la refermer :

}

Voici donc un petit récapitulatif de la fonction qui correspond aux besoins de mon programme Palne :

build() { cd $srcdir/$pkgname make || return 1 mkdir -p $pkgdir/usr/bin/ mkdir -p $pkgdir/usr/share/palne/ mkdir -p $pkgdir/usr/share/doc/palne/ mkdir -p $pkgdir/usr/man/man6/ mkdir -p $pkgdir/etc/palne/ mkdir -p $pkgdir/usr/share/licenses/palne/ cp bin/palne $pkgdir/usr/bin/ chmod +x $pkgdir/usr/bin cp doc/palne.6.gz $pkgdir/usr/man/man6/ cp doc/index.html $pkgdir/usr/share/doc/palne/ cp -r data/images/ $pkgdir/usr/share/palne/images/ cp data/conf/palne.cfg $pkgdir/etc/palne/ cp data/COPYING $pkgdir/usr/share/licenses/palne/ } Créer le paquet et le redistribuerCréation

Bon, nous savons créer un PKGBUILD basique, mais nous ne savons toujours pas comment obtenir le paquet !
En fait, vous allez rire mais le PKGBUILD, c'était une blague de mon invention et il ne sert à rien la création d'un paquet se limite à une commande.
Tout d'abord je vous recommande de mettre le PKGBUILD dans un répertoire créé à cet effet.

Maintenant, l'heure de vérité, lancez cette commande :

makepkg

Si tout se passe bien, il vous posera quelques questions, et vous retournerez dans votre prompt.
Mais mais, que vois-je ? Notre répertoire a été rempli !

$ ls src/ pkg/ PKGBUILD nom-version.tar.gz

Eh bien oui, ce fameux tar.gz est votre paquet. Vous ne me croyez pas ? Alors lancez l'installation avec yaourt -U nom-version.tar.gz puis testez votre programme avec palne.

Redistribution

Vous pouvez vous contenter de donner votre tar.gz au public via votre site internet ou alors la mettre dans les dépôts AUR d'ArchLinux.
C'est cette méthode que je vais vous présenter.

Tout d'abord, il faut vous inscrire sur le site officiel de AUR : http://aur.archlinux.org/account.php
Une fois inscrit, connectez-vous et choisissez « submit » (ou « soumettre » en français) dans le menu en haut.
Vous aurez deux champs : Package Category et Upload package file.
Pour la liste déroulante, vous mettrez la catégorie de votre paquet (dans le cas de mon exemple, ce serait un jeu).
Pour le fichier à sélectionner, nous allons le créer tout de suite...