Créer un paquet aur

yaourt

Pour commencer, nous allons voir très grossièrement ce que fait yaourt lorsqu’il installe un paquet.

  • Il télécharge du site web aur un fichier texte nommé PKGBUILD
  • il lance la commande makepkg PKGBUILD qui va créer une archive des fichiers à installer.
  • il décompresse cette archive à la racine de notre système et garde en mémoire juste la liste des fichiers de cette archive pour une éventuelle désinstallation.

makepkg

Toute la magie se situe avec makepkg qui va interpréter et exécuter le fichier PKGBUILD. Mais que fait réellement makepkg ?

  • il télécharge les sources d’un programmes dans ./src/
  • éventuellement il compile ces sources (fonction build())
  • il copie les fichiers dans ./src/ dans un dossier ./pkg/ (fonction package())
  • il crée une archive du dossier ./pkg/

Cette archive sera un paquet prêt à l’emploi que pacman pourra décompresser à la racine de notre système.

PKGBUILD

Ce fichier texte est constitué de variables (nom du paquet, url des sources…) et de fonctions qui ne sont que du code bash classique.

variables

  • pkgname : le nom unique du paquet
  • pkgver : la version qui va indiquer a yaourt si une nouvelle version est disponible
  • source : les endroits ou il faut télécharger les sources sur le web
  • depends : les dépendances obligatoire pour le bonne marche du programme
  • url : adresse web du programme

Certaines variables sont générées par le programme : srcdir, pkgdir, il est possible de se créer ces propres variables dont le nom débute par « _ »

J’ai omis d’autres variables, voir le wiki archlinux : https://wiki.archlinux.fr/PKGBUILD

Les fonctions

  • pkgver va dynamiquement retourner la version du programme. cette fonction optionnelle est utilisée pour les sources venant de git et svn. Avec git l’usage est d’afficher le nombre de commits point l’id du dernier commit sous la forme : « r10.fsde8007xo ». Un exemple git :
    pkgver() {
      cd "${pkgname}"
      # le dev tag ou pas ces commits ?
      if ($(git describe --long 2>/dev/null)); then
         git describe --long | sed 's/\([^-]*-g\)/r\1/;s/-/./g'
      else
         printf "r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
       fi
    }

    Pour le mainteneur, avec cette fonction, la valeur de la variable pkgver du fichier texte PKGBUILD sera mise à jour automatiquement lors d’un makepkg
    Pour l’utilisateur, cette fonction va lui permettre de récupérer éventuellement la toute dernière version avec l’option yaourt --devel même si le mainteneur n’a pas encore publié la dernière version

  • build va compiler les sources une fois téléchargées dans le sous-répertoire ./src/, généralement elle lance un make.
  • package est la fonction obligatoire qui va copier des fichiers en désordre dans ./src/ vers le sous-répertoire ./pkg/ . Ici nous utilisons les 2 variables srcdir et pkgdir et écrivons notre code bash.
    Par défaut nous sommes déjà dans le répertoire « ${srcdir}/ »

    package() {
         #cd "${srcdir}/"
         echo "les sources téléchargées sont dans : ${srcdir}/, nous sommes déjà dans $(pwd)"
         cp *.txt ${pkgdir}/   
    }

Un peu de pratique

Soit un paquet qui se nomme : monpaquet, nous le téléchargeons depuis un dépôt git quelconque, pas de compilation. Ce qui pourrait-être un programme bash, python ou des ressources : une bibliothèque d’images ou d’icônes …

Il suffit de créer un fichier texte du nom de PKGBUILD dans un dossier créé à son attention. ( ~/test/PKGBUILD)

# Maintainer: monnom <moi [at]serveur [dot] fr>
pkgname=monpaquet
pkgver=1
pkgrel=1
pkgdesc="il fait le café"
arch=('any')
url="https://github.com/nielsmde/gedit-markdown"
source=("$pkgname::git+https://github.com/nielsmde/gedit-markdown#branch=master")
license=('GPL')
#depends=('gedit')
makedepends=('git')
md5sums=('SKIP')

pkgver() {
  cd "${pkgname}"
  # cette solution car le dev ne tag pas ces gits :( 
  printf "r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
}
package(){
   echo "copie de src/ vers pkg/"
};

Pour le tester, aller dans notre répertoire « test » et lancer la commande :

makepkg -sf

Içi nous créons un paquet mais nous ne l’installons pas sur notre machine. Avec package() nous n’avons rien copier dans le sous répertoire ./pkg/ (=${pkgdir}); nous avons donc créer un paquet vide bien qu’il télécharge beaucoup de fichiers !

Il faut donc obligatoirement éditer la fonction package dans laquelle nous recréons une arborescence compatible avec notre système et nous y copions les fichiers voulus. Note : on ne copie rien dans le home de l’utilisateur aussi que d’autres répertoires (revoir wiki) !!!

Bien se rappeler que ${pkgdir} sera la racine du système hôte et donc toute opération dans cette fonction ne doit ce faire que sur cette destination.

Pour notre second test, nous allons nous faire un paquet de documentation. Pour comprendre le fonctionnement nous ajoutons des echo «  » et utilisons l’option -v (verbose) pour bien comprendre; bien sur cela ne doit pas rester dans la version finale ;)

package() {
   cd "${pkgname}"
   #pour debug/tests:
   echo "#########"
   echo "srcdir= ${srcdir}"
   echo "pkgdir= ${pkgdir}"
   echo "les sources du git téléchargées dans : ${srcdir}/${pkgname}"
   echo "notre dossier actuel: $(pwd)"
   echo "#########"
   # on utilise des cp -v uniquement pour voir ce qui ce passe !

   # la véritable INSTALLATION
   # on copie de ./src/ vers ./pkg/

   # on fait la doc
   mkdir -pv "${pkgdir}/usr/share/doc/${pkgname}/"
   cp -v *.md ${pkgdir}/usr/share/doc/${pkgname}/
}

Voila nous avons enfin un réel paquet (de ressources) qui va installer des fichiers dans le dossier /usr/share/doc/monpaquet/ de notre système. Dans cette fonction nous « abusons » de la variable ${pkgname} pour être bien sur que tout sera au bon endroit et ne viendra pas remplacer un fichier d’un autre paquet.

Nous pouvons maintenant utiliser sans modération la commande : makepkg -sf pour faire notre propre paquet. Parfois l’arborescence des sources est déjà bonne et la fonction package() se limite à un simple « cp » mais, généralement est plus complexe et requière l’emploi des commandes mkdir, cp et surtout install.

Une fois que tous les fichiers sont au bon emplacement, il ne reste plus qu’a installer le paquet : ajouter l’option -i à la commande makepkg déjà utilisée maintes fois

Share Button

Vous devriez aimer...

1 Response

  1. patrick dit :

    J’ai surtout voulu « bien  » expliquer makepkg (ou les entrailles de yaourt) car sinon il est compliqué de comprendre PKGBUILD. Et je suis passé très vite sur PKGBUILD en lui même, le wiki est suffisant et on trouve 30 000 exemples dans aur.