Après avoir créé un paquet source Debian, il peut être intéressant de le tester une première fois en le compilant soit même. On peut compiler un paquet de deux manières différentes.

La première est de simplement utiliser l'utilitaire debuild sans argument. Le paquet Debian sera alors compilé pour la machine donnée en se servant de ce qui est déjà installé. Cela demande donc d'avoir un environnement capable de compiler le paquet souhaité. Par exemple, les dépendances du paquet doivent être toutes installées.

La seconde méthode est d'utiliser un environnement spécifique pour compiler. Debian dispose d'outils permettant de mettre en place plusieurs debootstraps comme pbuilder et cowbuilder. Je préfère personnellement utiliser le second outil car le debootstrap met moins de temps à s'initialiser. L'utilisation de cowbuilder permet aussi de gérer la compilation de paquets pour plusieurs versions d'une distribution. En effet, il est très simple de mettre en place plusieurs environnements afin de compiler les paquets pour Debian Stable, Testing et Unstable (avec ou sans Experimental). Il est également possible de compiler les paquets pour différentes versions d'Ubuntu.

En réalité, cowbuilder est un simple outil utilisant pbuilder. On peut voir ça comme une surcouche un peu comme aptitude par rapport à apt. L'installation est très simple puisque tout est dans les dépôts.

apt-get install dh-make quilt cowbuilder

La configuration de cowbuilder/pbuilder se fait via le fichier .pbuilderrc situé dans le répertoire personnel de l'utilisateur lançant la compilation. Mettre le contenu suivant permettra à cowbuilder de compiler des paquets pour Debian et Ubuntu et pour les différentes versions des distributions.

# Codenames for Debian suites according to their alias. Update these when
# needed.
UNSTABLE_CODENAME="sid"
TESTING_CODENAME="strech"
STABLE_CODENAME="jessie"
STABLE_BACKPORTS_SUITE="$STABLE_CODENAME-backports"
 
# List of Debian suites.
DEBIAN_SUITES=($UNSTABLE_CODENAME $TESTING_CODENAME $STABLE_CODENAME
    "unstable" "testing" "stable")
 
# List of Ubuntu suites. Update these when needed.
UBUNTU_SUITES=("precise" "trusty", "utopic", "vivid")
 
# Mirrors to use. Update these to your preferred mirror.
DEBIAN_MIRROR="ftp.fr.debian.org"
UBUNTU_MIRROR="ftp.ubuntu.com"
 
# Optionally use the changelog of a package to determine the suite to use if
# none set.
if [ -z "${DIST}" ] && [ -r "debian/changelog" ]; then
    DIST=$(dpkg-parsechangelog | awk '/^Distribution: / {print $2}')
    DIST="${DIST%%-*}"
    # Use the unstable suite for certain suite values.
    if $(echo "experimental UNRELEASED" | grep -q $DIST); then
        DIST="$UNSTABLE_CODENAME"
    fi
fi
 
# Optionally set a default distribution if none is used. Note that you can set
# your own default (i.e. ${DIST:="unstable"}).
: ${DIST:="$(lsb_release --short --codename)"}
 
# Optionally change Debian release states in $DIST to their names.
case "$DIST" in
    unstable)
        DIST="$UNSTABLE_CODENAME"
        ;;
    testing)
        DIST="$TESTING_CODENAME"
        ;;
    stable)
        DIST="$STABLE_CODENAME"
        ;;
esac
 
# Optionally set the architecture to the host architecture if none set. Note
# that you can set your own default (i.e. ${ARCH:="i386"}).
: ${ARCH:="$(dpkg --print-architecture)"}
 
NAME="$DIST"
if [ -n "${ARCH}" ]; then
    NAME="$NAME-$ARCH"
    DEBOOTSTRAPOPTS=("--arch" "$ARCH" "${DEBOOTSTRAPOPTS[@]}")
fi
# BASETGZ="/var/cache/pbuilder/$NAME-base.tgz"
# Optionally, set BASEPATH (and not BASETGZ) if using cowbuilder
BASEPATH="/var/cache/pbuilder/$NAME/base.cow/"
DISTRIBUTION="$DIST"
BUILDRESULT="/var/cache/pbuilder/$NAME/result/"
APTCACHE="/var/cache/pbuilder/$NAME/aptcache/"
BUILDPLACE="/var/cache/pbuilder/build/"
 
if $(echo ${DEBIAN_SUITES[@]} | grep -q $DIST); then
    # Debian configuration
    MIRRORSITE="http://$DEBIAN_MIRROR/debian/"
    COMPONENTS="main contrib non-free"
    DEBOOTSTRAPOPTS=("${DEBOOTSTRAPOPTS[@]}" "--keyring=/usr/share/keyrings/debian-archive-keyring.gpg")
 
elif $(echo ${UBUNTU_SUITES[@]} | grep -q $DIST); then
    # Ubuntu configuration
    MIRRORSITE="http://$UBUNTU_MIRROR/ubuntu/"
    COMPONENTS="main restricted universe multiverse"
    DEBOOTSTRAPOPTS=("${DEBOOTSTRAPOPTS[@]}" "--keyring=/usr/share/keyrings/ubuntu-archive-keyring.gpg")
    OTHERMIRROR="deb http://ppa.launchpad.net/gnome-split-team/ppa/ubuntu raring main"
else
    echo "Unknown distribution: $DIST"
    exit 1
fi

Pour utiliser cowbuilder il faut posséder les droits d'administration. En effet, toutes les actions effectuées par cowbuilder sont faites dans le répertoire système /var/cache. Voici un exemple d'utilisation. On veut construire le paquet binaire fournissant GNOME Split pour Debian Testing et Ubuntu Oneiric Ocelot 11.10. On commence par préparer le paquet (ici il s'agit de sources préparés et d'un répertoire debian/ existant mais dans le cas d'un nouveau paquet, il faudra faire ce travail manuellement).

# User for Debian SVN repo
USER="testuser"
 
wget http://gnome-split.org/releases/gnome-split-1.1.tar.bz2
svn checkout svn+ssh://${USER}-guest@svn.debian.org/svn/pkg-java/trunk/gnome-split
 
mv gnome-split-1.1.tar.bz2 gnome-split_1.1.orig.tar.bz2
tar jxvf gnome-split_1.1.orig.tar.bz2
cp -r gnome-split/debian gnome-split-1.1

Le répertoire du paquet est prêt et le tarball des sources a été correctement renommé. On peut donc maintenant construire le paquet source.

cd gnome-split-1.1
debuild -S -us -uc

Ici on ne signe pas le paquet avec GPG mais avant un upload dans Debian ou tout autre dépôt il faut le faire. Cela permet de s'assurer que le paquet est bien le bon lorsque l'utilisateur le récupérera via APT.

Nous avons le paquet source de GNOME Split, nous allons donc maintenant construire le paquet binaire mais avant il faut mettre en place nos deux debootstraps : un pour Debian Testing et l'autre pour Ubuntu 11.10. Les actions suivantes sont à effectuer en root.

DIST="testing" cowbuilder --create
DIST="oneiric" cowbuilder --create

Cela va créer les deux environnements de compilation. La mise en place de ces environnements peut prendre un peu de temps (téléchargements des paquets, installation et configuration). Après une construction de paquet, ces environnements sont remis à leur état initial afin d'entamer une nouvelle compilation comme sur une machine vierge de toutes modifications.

Les environnements prêts, nous pouvons lancer la compilation du paquet binaire.

cd .. # Retour au répertoire contenant le fichier *.dsc
DIST="testing" cowbuilder --build *.dsc
DIST="oneiric" cowbuilder --build *.dsc

Le lancement de la compilation va provoquer l'utilisation du debootstrap approprié, télécharger les dépendances et lancer les règles définies pour construire le paquet Debian. Une fois l'opération terminée, on obtient les résultats dans un répertoire de la forme “/var/cache/pbuilder/${DIST}-${ARCH}/result/”.

Pour utiliser le dépôt Experimental de Debian dans un environnement cowbuilder, on crée d'abord un debootstrap basé sur la version Unstable.

DIST="unstable" cowbuilder --create

Puis il faut se logger dans le debootstrap pour modifier le fichier sources.list de APT afin d'y ajouter le dépôt Experimental.

DIST="unstable" cowbuilder --login --save-after-login
echo "deb http://ftp.fr.debian.org/debian experimental main" >> /etc/apt/sources.list
exit

Puis il ne reste qu'à mettre à jour le cowbuilder pour qu'il prenne en compte la modification de la liste des dépôts.

DIST="unstable" cowbuilder --update

Si la prochaine compilation de paquet nécessite des dépendances qui ne se trouvent que dans Experimental, seules ces dépendances seront récupérés depuis ce dépôt, tout le reste continuera de provenir des dépôts de Unstable.