Ceux que nous avons vu jusqu'à maintenant sont assez basiques, nous allons donc en voir quelques-uns plus complexes, par exemple avec gestion des patchs ou d'un système de versionnage.
C'est parti !
Les gestionnaires de versions
Comme je n'ai pas une imagination infinie, je vais simplement réutiliser mon ancien PKGBUILD et le transformer pour utiliser le gestionnaire de versionnage
git.
Pour ceux qui l'auraient oublié, en voici le code :
Secret (cliquez pour afficher)Code : Bash 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39 | # Maintainer: Adrien Perkele <perkele@domain.tld>
# Contributor: Adrien Perkele <perkele@domain.tld>
pkgname=palne
pkgver=1
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
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/
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/
}
|
On va donc commencer par renommer le paquet pour préciser qu'il utilise les versions de développement, par exemple palne-git.
Maintenant, il va falloir préciser que git est nécessaire à la compilation :
Code : Bash
Étant donné que nous ne téléchargeons plus les sources par une archive sur le net, il va falloir supprimer le contenu de
source et de
md5sums :
Code : Bash
Maintenant, pour que le code soit plus clair, nous allons créer deux variables personnalisées. Néanmoins, pour éviter d'éventuels conflits, nous allons mettre un underscore (
_) avant le nom de la variable. Nous allons donc créer nos deux variables, une pour la racine de notre
repository et une pour le nom du répertoire à créer, par exemple :
Code : Bash | _gitroot="git://git.palne.net/palne"
_gitname="palne"
|
Pour la suite, nous allons modifier la fonction build().
Remplacez la première ligne
cd $srcdir/$pkgname
par un simple
cd $srcdir
.
Ensuite nous allons vérifier si le
repository a déjà été récupéré ou s'il faut le faire :
Code : Bash | if [[ -d $_gitname ]] ; then
# Le repository a déjà été récupéré, on le met a jour
else
# on doit le récupérer
fi
|
Pour mettre à jour notre
repository, nous allons faire comme cela (et laisser un petit message) :
Code : Bash | git-pull origin || return 1
msg "Les fichiers locaux ont été mis à jour."
|
À noter que je n'ai pas oublié de finir par ligne par un
|| return 1 pour préciser que si la fonction échoue, la suite ne fonctionnera pas.
Maintenant, pour récupérer le
repository, nous allons faire ainsi :
Code : Bash | git clone $_gitroot || return 1
msg "Les fichiers ont été téléchargés."
|
Nous avons fini, c'était si compliqué ?
Pour ceux qui n'auraient pas bien compris où placer le code, voici un récapitulatif du PKGBUILD :
Code : Bash 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53 | # Maintainer: Adrien Perkele <perkele@domain.tld>
# Contributor: Adrien Perkele <perkele@domain.tld>
pkgname=palne-git
pkgver=1
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=('git')
conflicts=('kipalne')
replaces=('palneuh')
backup=('etc/palne/palne.conf')
install=
source=()
md5sums=()
_gitroot="git://git.palne.net/palne"
_gitname="palne"
build()
{
msg "Récupération des sources sur le serveur git"
if [[ -d $_gitname ]] ; then
git-pull origin || return 1
msg "Les fichiers locaux ont été mis à jour."
else
git clone $_gitroot || return 1
msg "Les fichiers ont été téléchargés."
fi
cd $_gitname
msg "Récupération des sources terminée"
msg "Début de la compilation"
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/
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/
}
|
Appliquer un patch
Maintenant, éloignons-nous un peu des PKGBUILD pour nous intéresser à deux commandes très utiles, j'ai nommé diff et patch.
diff sert à calculer la différence entre deux ensemble de fichiers tandis que
patch sert, à partir du résultat de la commande précédente et des sources, à obtenir la version modifiée des sources.
Pour comprendre le fonctionnement de ces commandes, je vous propose donc cet exemple simple :
Nous avons deux fichiers, code.c.old et code.c :
Code : C | #include <stdio.h>
int main(int a, char **b)
{
printf("Hello world!");
return 0;
}
|
| #include <stdio.h>
int main(int a, char **b)
{
printf("Bonjour le monde !");
return 0;
}
|
La seule chose qui change entre ces deux codes est le texte, l'un en anglais, l'autre en français.
Pour créer un patch, on va donc exécuter la commande diff ainsi :
Code : Console | diff -c code.c.old code.c > code.diff |
Si vous ouvrez le fichier code.diff, vous aurez un résultat semblable à celui-ci :
Code : Diff 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 | *** code.c.old 2010-05-13 16:49:09.000000000 +0200
--- code.c 2010-05-13 16:47:58.000000000 +0200
***************
*** 2,7 ****
int main(int a, char **b)
{
! printf("Hello World!");
return 0;
}
--- 2,7 ----
int main(int a, char **b)
{
! printf("Bonjour le monde !");
return 0;
}
|
Bien sûr, en général, vous allez devoir comparer plusieurs fichiers pour un même patch.
Pour cela, vous allez créer un répertoire contenant les anciennes sources, code-old par exemple, et un autre contenant les sources à jour, code. La commande sera donc :
Code : Console | diff -cr code-old/ code/ > code.diff |
Où -r est le mode récursif.
C'est bien beau mais à quoi sert ce fichier .diff si on ne le réutilise pas ?
Pour ce faire, on va utiliser la commande patch dans le répertoire code-old ainsi :
Code : Console
Où -p0 est le mode récursif.
Voilà, maintenant que nous connaissons le fonctionnement de la commande patch et que nous avons notre diff, nous allons pouvoir utiliser tout ceci dans un paquet et ce n'est pas plus compliqué que ça !
Tout d'abord, il faudra héberger votre diff quelque part, et le rajouter dans le tableau
source ainsi que son md5sums dans le tableau correspondant :
Code : Bash | source=(http://palne.net/$pkgname-$pkgver.pkg.tar.gz http://palne.net/patch.diff)
md5sums=('40972633cea6c8d38ff26dade3eec51e' '8def8b39aceae8e27fdcf2af107991cb')
|
Juste avant la compilation, dans notre fonction build(), on ajoute un simple :
Code : Bash | patch < $srcdir/patch.diff
|
Et voilà, les sources du paquet sont patchées !
Création de paquets avec ArchLinux
Durée d'étude :
2
heures
Perkele
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+