Le guide du SlackBuild

Ce guide a été réalisé dans le but d'uniformiser un minimum les SlackBuilds créés par les différents contributeurs de ce site en posant des règles de base obligatoires. Ces principes de base servent avant tout à créer des SlackBuilds qui généreront (normalement) des packages à la fois de qualité et respectant la “philosophie Slackware”.
La syntaxe shell utilisée est laissée au choix du créateur de SlackBuild, sauf indication contraire, tant que le résultat recherché est le même. Prenez cependant l'habitude de faire des SlackBuilds clairs, commentés (mais pas trop), et pas trop complexes (un débutant ne doit pas avoir trop de mal à comprendre ce que fait votre SlackBuild en le lisant).
Les principes ci-dessous sont énumérés dans la mesure du possible dans un ordre à priori logique, en suivant l'ordre du SlackBuild d'exemple.
Enfin, il est vivement conseillé de lire la FAQ en plus de ce document qui apporte de nombreuses précisions non abordées ici.

Note : les titres marqués d'un * en fin de ligne indiquent des parties obligatoires.

Un SlackBuild est composé de plusieurs fichiers :

• mysoftware.SlackBuild (le SlackBuild même)
• slack-desc (fichier de description requis)
• doinst.sh (script de post-installation facultatif)
• d'autres éventuels fichiers…

Si le succès de la compilation du logiciel que vous empaquetez dépend d'une ou plusieurs applications (ou bibliothèques) qui ne sont pas incluses dans Slackware, vous devez le signaler au début de votre Slackbuild en utilisant la syntaxe suivante :

# Depends: ap/logiciel1, d/logiciel2, l/bibliothèque1

Si elle peut proposer des fonctionnalités supplémentaires dans le cas où certains logiciels tiers sont présents lors de la compilation, vous pouvez le signaler par cette en-tête :

# Suggests: ap/logiciel1, d/logiciel2, l/bibliothèque1

Les variables sont libre de choix. Cependant, quelques variables communes et obligatoires ont été définies. Leur syntaxe particulière permet à l'utilisateur de les modifier sans éditer le SlackBuild car elles sont de la forme VARIABLE=${VARIABLE:-ValeurParDefaut}.
Les voici :

NAMESRC=${NAMESRC:-mysoftware}  # Nom de l'archive du logiciel à télécharger (par exemple "MPlayer")
VERSION=${VERSION:-1.0}  # Version du logiciel
EXT=${EXT:-tar.bz2/tar.gz/tgz}  # Format de l'archive
NAMEPKG=${NAMEPKG:-mysoftware}  # Nom final du paquet à construire (par exemple "mplayer")
PKGEXT=${PKGEXT:-tgz/txz}  # Format du paquet à construire (seul le format tgz est pris en compte par les versions de slackware antérieures à 13.0)
BUILD=${BUILD:-1sfo}  # *OBLIGATOIRE* Version du paquet (1ère version du paquet créée par/pour slackware-fr.org dans ce cas)
 
TMP=${TMP:-/tmp}  # *OBLIGATOIRE* Répertoire temporaire de compilation
OUT=${OUT:-$TMP/build}  # *OBLIGATOIRE* Répertoire où le paquet sera créé
ARCH=${ARCH:-i486/x86_64} # *OBLIGATOIRE* Architecture. Mettez i486 pour slackware 32bits et x86_64 pour slackware 64bits.
TARGET=${TARGET:-$ARCH} # Si vous mettez une valeur autre que i486 ou x86_64 pour $ARCH, vous devez quand même utiliser l'une de ces deux valeurs pour $TARGET
WGET=${WGET:-http://www.mysoftware.org/$NAMESRC-$VERSION.$EXT}  # Lien de téléchargement des sources
SUM=${SUM:-the_sha1sum_can_be_include_in_the_SB}  # Somme SHA1 sans le nom du fichier
DOC=${DOC:-ChangeLog AND OTHER FILES AND DIRECTORIES CONTAINING doc/}  # Documents à installer (sauf manpages)

TMP=~/tmp ./mysoftware.SlackBuild

set -e  # Le Slackbuild s'arrête dès qu'il y a une erreur
umask 022  # Les répertoires et fichiers créés auront respectivement les droits 755 et 644
 
# Le SlackBuild vérifie que vous ne le lancez pas en root.
if [ "$(id -u)" = "0" ]; then
  echo "You shouldn't run this SlackBuild as ROOT !"
  sleep 10
fi

On vérifie si les sources sont présentes et les télécharge si besoin.

if [ ! -r $NAMESRC-$VERSION.$EXT ]; then
  wget -vc $WGET -O $NAMESRC-$VERSION.$EXT.part
  mv $NAMESRC-$VERSION.$EXT.part $NAMESRC-$VERSION.$EXT
fi

Puis on vérifie la somme SHA1.

if [ -n $SUM ]; then
  echo "$SUM  $NAMESRC-$VERSION.$EXT" > $NAMESRC-$VERSION.$EXT.sha1
  sha1sum -c $NAMESRC-$VERSION.$EXT.sha1
elif [ -f $NAMESRC-$VERSION.$EXT.sha1 ]; then
  sha1sum -c $NAMESRC-$VERSION.$EXT.sha1
fi

On se rappelle le répertoire où est situé le SlackBuild.

CWD=$(pwd)

Il faut connaître le nom du répertoire temporaire utilisé pour la construction du paquet (make install) ; répertoire différent de $TMP où l'on extrait et compile les sources.

PKG=$TMP/build/$NAMEPKG

Le répertoire des sources contenu dans l'archive peut être différent du nom de l'archive, il faut donc le connaître également.

NAME=$(tar ft $NAMESRC-$VERSION.$EXT | head -n 1 | awk -F/ '{ print $1 }')

On passera ces options au script ./configure à partir de la variable $ARCH.

case $ARCH in
  i386)SLKCFLAGS="-O2 -march=i386 -mtune=i686";LIBDIRSUFFIX="";;
  i486)SLKCFLAGS="-O2 -march=i486 -mtune=i686";LIBDIRSUFFIX="";;
  i586)SLKCFLAGS="-O2 -march=i586 -mtune=i686";LIBDIRSUFFIX="";;
  i686)SLKCFLAGS="-O2 -march=i686 -mtune=i686";LIBDIRSUFFIX="";;
  s390)SLKCFLAGS="-O2";LIBDIRSUFFIX="";;
  x86_64)SLKCFLAGS="-O2 -fPIC";LIBDIRSUFFIX="64"
esac

On vérifie que le répertoire temporaire $TMP existe.

if [ ! -d $TMP ]; then
  echo "$TMP doesn't exist or is not a directory !"
  exit 1
fi

On renseigne le script ./configure des options de compilation puis on compile et installe dans le répertoire temporaire $PKG.

cd $TMP
echo "Building $NAMESRC-$VERSION.$EXT..."
tar xf $CWD/$NAMESRC-$VERSION.$EXT
cd $NAME
CFLAGS=$SLKCFLAGS \
CXXFLAGS=$SLKCFLAGS \
./configure \
  --prefix=/usr \
  --libdir=/usr/lib${LIBDIRSUFFIX} \
  --sysconfdir=/etc \
  --mandir=/usr/man \
  --docdir=/usr/doc/$NAMEPKG-$VERSION \
  --build=$TARGET-slackware-linux
 
make -j3
make install DESTDIR=$PKG

• Pour certains logiciels (bibliothèque par exemple), il est utile d'utiliser les options suivantes :

  --enable-shared
  --disable-static

• Pour les logiciels de type serveur (le proxy privoxy par exemple) l'option suivante est nécessaire :

  --localstatedir=/var

Maintenant le répertoire temporaire d'installation $PKG contient le résultat de la compilation.
Il reste donc à installer certains fichiers permettant de créer un paquet propre à Slackware.

mkdir -p $PKG/install
cat $CWD/slack-desc > $PKG/install/slack-desc

if [ -r $CWD/doinst.sh ]; then
  cat $CWD/doinst.sh > $PKG/install/doinst.sh
fi

On installe la documentation fournie par la variable $DOC dans /usr/doc/logiciel-version (emplacement obligatoire).

mkdir -p $PKG/usr/doc/$NAMEPKG-$VERSION
cp -a $DOC $PKG/usr/doc/$NAMEPKG-$VERSION

On compresse les manpages et infopages simplement pour optimiser l'espace disque.

# Compress the man pages
if [ -d $PKG/usr/man ]; then
  find $PKG/usr/man -type f -name "*.?" -exec gzip -9 {} \;
  for manpage in $(find $PKG/usr/man -type l) ; do
    ln -s $(readlink $manpage).gz $manpage.gz
    rm -f $manpage
  done
fi
 
# Compress the info pages
if [ -d $PKG/usr/info ]; then
  rm -f $PKG/usr/info/dir
  gzip -9 $PKG/usr/info/*.info*
fi

Les exécutables (binaires) et les bibliothèques partagées doivent être strippés, c'est-à-dire épurés de leurs symboles de debug (entraînant une empreinte mémoire plus faible et des paquets plus petits notamment).

find $PKG -type f | xargs file | grep "LSB executable" | cut -f 1 -d : | xargs \
  strip --strip-unneeded 2> /dev/null || echo "No binaries to strip"
find $PKG -type f | xargs file | grep "shared object" | cut -f 1 -d : | xargs \
  strip --strip-unneeded 2> /dev/null || echo "No shared objects to strip"
find $PKG -type f | xargs file | grep "current ar archive" | cut -f 1 -d : | \
  xargs strip -g 2> /dev/null || echo "No archives to strip"

Deux cas de figure se présentent :

• soit vous avez fakeroot d'installé et aucun mot de passe ne sera nécessaire (méthode par défaut et conseillée),
• soit vous n'avez pas fakeroot d'installé et le mot de passe root sera requis,

cd $PKG
mkdir -p $OUT
PACKAGING="
chown root:root . -R
/sbin/makepkg -l y -c n $OUT/$NAMEPKG-$VERSION-$ARCH-$BUILD.$PKGEXT
rm -rf $PKG
rm -rf $TMP/$NAME
"
if [ "$(which fakeroot 2> /dev/null)" ]; then
  echo "$PACKAGING" | fakeroot
else
  su -c "$PACKAGING"
fi

Ce fichier de description requis est écrit de la manière suivante :

          |-----handy-ruler------------------------------------------------------|
mysoftware: mysoftware (description courte)
mysoftware:
mysoftware: Description longue
mysoftware:
mysoftware:
mysoftware:
mysoftware:
mysoftware:
mysoftware:
mysoftware:
mysoftware:

Il doit obligatoirement :

• |-----handy-ruler------------------------------------------------------| qui doit faire exactement cette taille, doit être aligné sur les : de mysoftware: juste en dessous (à noter que les pkgtools n'interprètent pas ce handy-ruler, c'est juste une indication pour le créateur de slack-desc pour que la description longue ne dépasse pas),
• avoir exactement 11 lignes commençant par le nom du logiciel suivi de deux points,
• ce nom de logiciel doit être exactement le même que celui de la variable $NAMEPKG.

Ce script est exécuté à la fin de l'installation d'un paquet.
Il est souvent utilisé pour copier un fichier de configuration ou un script de démarrage d'un service sans écraser ceux existants en vérifiant la somme MD5. Tous les fichiers et répertoires créés par ce script ne seront pas supprimer lors de la désinstallation du paquet.
Voici le doinst.sh :

#! /bin/sh
 
config() {
  NEW="$1"
  OLD="`dirname $NEW`/`basename $NEW .new`"
  # If there's no config file by that name, mv it over:
  if [ ! -r $OLD ]; then
    mv $NEW $OLD
  elif [ "`cat $OLD | md5sum`" = "`cat $NEW | md5sum`" ]; then # toss the redundant copy
    rm $NEW
  fi
  # Otherwise, we leave the .new copy for the admin to consider...
}
 
umask 022
config etc/rc.d/rc.mon_daemon.new

Vous remarquez qu'on retrouve la commande umask 022 pour les mêmes raisons évoquées dans le SlackBuild.

Imaginons que vous voulez créer un SlackBuild pour lighttpd (serveur web), il vous faudra copier et tester le script /etc/rc.d/rc.lighttpd.new. Pour cela il faut :

1. depuis le SlackBuild, copier le script comme ceci :

   mkdir -p $PKG/etc/rc.d
   cat $CWD/rc.lighttpd.new > $PKG/etc/rc.d/rc.lighttpd.new

2. depuis doinst.sh, remplacer la ligne

   config etc/rc.d/rc.mon_daemon.new

   par

   config etc/rc.d/rc.lighttpd.new

A l'installation du paquet, si /etc/rc.d/rc.lighttpd n'existe pas, rc.lighttpd.new sera renommé en /etc/rc.d/rc.lighttpd.

• Il est conseillé de mettre une licence (impérativement libre si vous distribuez votre SlackBuild sur ce site) sur son travail, au choix. Elle doit être indiquée en début de script en commentaire. Par exemple :
  

  # Ce script est sous licence CeCILL dans sa version 2 et supérieure visible à http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt

• Il est recommendé d'insérer en entête de votre SlackBuild la page du projet du logiciel compilé. Exemple :
  

  # Latest Logiciel sourcecode is available at:
  # http://logiciel.sourceforge.net

• Comme vu précédemment, un SlackBuild ne doit pas être lancé en root, dans la mesure du possible. Exemple de vérification à faire :
  

  if [ "$(id -u)" = "0" ]; then
    echo "Ne pas exécuter en tant qu'utilisateur ROOT !"
    sleep 10
  fi

• Vérifiez si le repertoire de travail existe avec une condition :
  

  if [ ! -d $TMP ]; then
     echo "$TMP n'existe pas ou n'est pas un répertoire !"
     exit 1
  fi

Tags