piernov

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Faire un paquet pkg++ selon les règles ======


Compiler une application n'est souvent pas bien plus compliqué que de décompresser les sources et de lancer par la suite les commandes suivantes :

  # ./configure 
  # make 
  # make install

En revanche, lorsqu'il s'agit d'empaqueter une application afin de pouvoir partager les binaires avec d’autres utilisateurs, les choses se compliquent.

**pkg++** offre une solution en vous permettant de construire des paquets le plus simplement possible.

===== Prérequis =====

Voici ce dont vous avez besoin pour créer un paquet **pkg++** :

  * Un éditeur de texte (nano, gedit, etc.)
  * Quelques notions de shell
  * pkg++
  * Les dépendances de l’outil que vous voulez empaqueter

===== pkg++ =====

Un paquet n'est rien d'autre qu'une archive portant généralement une extension propre au gestionnaire de paquet, //.rpm// pour **RPM** ou //.deb// pour **dpkg** par exemple, qui contient tous les fichiers de l'application, ainsi que les fichiers nécessaires à son intégration dans la distribution.\\
Ce paquet pourra ensuite être installé sur votre système grâce à votre gestionnaire de paquet (comme **RPM** ou **dpkg**) et il se retrouvera dans la base de données des paquets installés sur votre système.\\
Pour construire un paquet, il est nécessaire d'écrire un fichier, un //Pkgfile// pour **pkg++**.

==== /etc/pkg++.conf ====


Ce fichier de configuration est lu par **pkg++** avant l'interprétation du fichier **Pkgfile**.\\
Voici à quoi il peut ressembler :

<code>
#
# /etc/pkg++.conf: pkg++(8) configuration
#

# For optimisation with CFLAGS, you can see
# http://en.gentoo-wiki.com/wiki/Safe_Cflags
# It is *strongly recommended* to use a known -march= and not -march=native,
# because your package will be optimised for an unknown processor, which would
# be a problem to share them.

export CHOST=$MACHTYPE

export CFLAGS="-O2 -march=i686 -pipe"
export CXXFLAGS="$CFLAGS"

export MAKE_OPTS="-j2"

# Do NOT export USE directly, ZSH hates this.
USE=(nls man info free -binary)

# PKGMK_SOURCE_MIRRORS=()
PKGMK_SOURCE_DIR="/var/cache/pkg++/sources"
PKGMK_PACKAGE_DIR="/var/cache/pkg++/packages"
PKGMK_LOGS_DIR="/var/log/pkg++"
PKGMK_WORK_DIR="/tmp/work-$name"
# PKGMK_DOWNLOAD="no"
# PKGMK_IGNORE_FOOTPRINT="no"
# PKGMK_IGNORE_NEW="no"
# PKGMK_NO_STRIP="no"
# PKGMK_WGET_OPTS=""
# PKGMK_CURL_OPTS=""
# PKGMK_COMPRESSION_MODE="gz"
# PKGMK_MAN_COMPRESSION="gz"

# Variable               # Values
PKGMK_DOWNLOAD_TOOL=curl # curl wget axel
PKGMK_UNTAR_TOOL=gtar    # gtar bsdtar sltar
PKGMK_TARLIST_TOOL=gtar  # gtar bsdtar
PKGMK_UNRPM_TOOL=rpm     # rpm bsdtar
PKGMK_UNZIP_TOOL=unzip   # unzip bsdtar

# These variables will be used for the packages construction.
PKGMK_PACKAGE_MANAGER=pkgutils

# End of file
</code>

On y remarque donc les //CFLAGS// et //CXXFLAGS// (optimisations) utilisés pour la compilation du paquet lorsque cette optimisation est possible.\\
Cette ligne : //PKGMK_SOURCE_DIR="/var/cache/pkg++/sources"//, indique où se trouvent sur le système de l'//empaqueteur// les sources téléchargées ou devant être téléchargés grâce à l'indication se situant dans le fichier **Pkgfile**.\\
Cette ligne : //PKGMK_PACKAGE_DIR="/var/cache/pkg++/packages"// indique quant à elle où se trouve le répertoire de l'//empaqueteur// qui contient les paquets une fois construit.

===== Votre dossier source =====

Il s'agit du dossier à partir duquel vous allez construire votre paquet, il contient obligatoirement le fichier **Pkgfile**, peut déjà contenir un fichier **.md5sum**, un fichier **.sha256sum**, un fichier **.footprint**, et éventuellement des patchs, des images, des fichiers .desktop, etc...

==== Arborescence ====


Voici l'arborescence de vos dossiers de construction correspondant au fichier de configuration /etc/pkg++.conf décrit plus haut.\\
Les fichiers sources de l'application se trouve dans **/var/cache/pkg++/sources/** \\
Le paquet binaire se retrouvera dans **/var/cache/pkg++/packages/** \\
Votre dossier de recette peut se situer n'importe où. Voici un exemple de son contenu :
\\
<code>
appli_test/
|-Pkgfile
|-.md5sum
|-.sha256sum
|-.footprint
|-appli_test.desktop
|-appli_test.png
|-appli_test_bugfix.patch
</code>

==== Pkgfile ====

Le fichier **Pkgfile** va décrire comment le paquet doit être construit. Une fois ce fichier écrit convenablement, l'//empaqueteur// n'aura qu'à y changer généralement que la version du paquet pour mettre à jour l'application.\\
Ce fichier est toujours rédigé de la même façon.\\
Chaque ligne de ce fichier est lue et a son importance.

<code>
description="Une description concise du paquet."
packager="Nom de l’empaqueteur <Adresse de contact>"
maintainer="Nom du mainteneur <Adresse de contact>"
url="Adresse du site Web de l'application."
depends=( Dépendances du paquets, séparés par une espace )

name=nom_du_paquet
version=version_du_paquet
release=numéro_de_construction_du_paquet
source=(
	L'URI d'où télécharger les sources de l'application
	fichier.desktop (si nécessaire)
	fichier.png (si nécessaire)
	fichier1.patch (si nécessaire)
	fichier2.patch (si nécessaire)
)

build () 
{ 
	cd $name-$version
	./configure \
		--prefix=/usr 
	make
	make DESTDIR=$PKG install
}
</code>

=== La fonction build ===

La fonction //build// est ceci :
<code>
build() {

}
</code>

Les instructions se trouvant dans cette fonction sont toutes les instructions requises pour compiler les sources qui se trouveront décompressées dans le dossier $SRC ( /tmp/work-nom_du_paquet/src/ ).

La plupart du temps, cette fonction sera juste équivalente à :

<code>
build() {
cd $name-$version
        ./configure –prefix=/usr
        make
        make DESTDIR=$PKG install
}
</code>

Voire, ceci pour une application Perl :
<code>
build() {
cd URI-$version
	perl Makefile.PL
	make
	make DESTDIR=$PKG install
}
</code>

Ou encore ceci pour une application Python :
<code>
build() {
cd $name-$version
	python setup.py build install --root=$PKG       
}
</code>

Pour plus d'information, lisez le fichier INSTALL ou README contenu dans l'archive de l'application, ou lisez sa documentation.

En sachant que $PKG représente le répertoire de destination qui sera contenu dans le paquet ( /tmp/work-nom_du_paquet/pkg )

Parfois, bien évidemment, il peut être nécessaire d'appliquer des patchs, d'ajouter une icône pour le menu, un fichier .desktop pour l'apparition de votre application dans le menu de votre bureau.\\

Ce que vous n'avez pas à faire car **pkg++** le fait pour vous :\\
-Archiver et compresser les pages man et les pages info.
-Fixer les permissions du paquet à root:root (sauf exception, voir au bas de la page )


==== .md5sum, .sha256sum et .footprint ====
 
Le fichier **.md5sum** correspond à la somme MD5 des sources de l'application.\\
De même, le fichier **.sha256sum** correspond à la somme SHA256 des sources de l'application.\\
Le fichier **.footprint** correspond à l'//empreinte// du paquet construit, il indique le contenu de ce dernier.\\
Bien évidemment, avant la première construction, ces 3 fichiers n'existent pas.\\
\\
A la prochaine construction, c'est à dire lors d'une mise à jour de votre paquet, si vous mettez à jour le numéro de version de l'application, les sources du paquets sont modifiées, il est donc nécessaire de mettre à jour les fichier .md5sum et .sha256sum :

  # pkg++ -um -us

L'empreinte de votre paquet changera aussi sûrement, vous aurez sûrement droit à un message d'avertissement vous prévenant que le contenu du paquet à changé et que la fabrication du paquet a échoué. Il sera donc nécessaire de mettre à jour cette empreinte avant de relancer la construction :

  # pkg++ -uf

==== .desktop ====

Ce fichier répond aux standards FreeDesktop et est utile à l'intégration de votre application dans votre environnement de bureau.\\
Il est généralement de cette forme :

<code>
[Desktop Entry]
Encoding=UTF-8
Name=Le nom de l'application
Comment=Une description courte de l'application
Exec=Le nom de l'exécutable se trouvant dans le $PATH
Icon=Le nom de l'icone de l'application ( sans le chemin complet, sans extension )
Terminal=false
Type=Application
Categories=Application;System;  (catégorie du menu, voir lien ci dessous)
StartupNotify=true
</code>

Les catégories selon les standards [[http://standards.freedesktop.org/menu-spec/menu-spec-1.0.html#category-registry|FreeDesktop]].\\
Ce fichier doit se nommer $name.desktop (ou $name = nom de l'application, comme dans le Pkgfile) et doit se trouver dans le dossier /usr/share/applications/

Si vous avez créé ce fichier à la main dans votre répertoire source, vous le déclarez au niveau source du build puis vous le copiez dans le paquet, au bon endroit, généralement comme ceci : 
 
<code>
mkdir -p $PKG/usr/share/applications
install -m 644 ../$name.desktop $PKG/usr/share/applications/
</code>


==== L'icône de l'application ====

Le paquet doit contenir, toujours pour respecter les standards FreeDesktop, une icône qui doit porter le nom déclaré dans le fichier .desktop à la ligne Icon= \\
Cette icône peut être soit de format .png, soit de format .svg\\

Si elle est au format PNG, elle doit se trouver, selon sa taille, dans le dossier /usr/share/icons/hicolor/48x48/apps/ (ici, taille de 48x48, qui est la taille recommandée par défaut)

Si elle est au format SVG, elle doit se trouver dans le dossier /usr/share/icons/hicolor/scalable/apps/

Donc, idem, si vous avez l'icône dans votre répertoire source de travail, vous la déclarez au niveau source du build, puis vous la copiez dans le paquet, au bon endroit, généralement comme ceci :

<code>
mkdir -p $PKG/usr/share/icons/hicolor/48x48/apps/
install -m 644 ../$name.png $PKG/usr/share/icons/hicolor/48x48/apps/
</code>

L'icône est indispensable pour l'intégration à l'environnement de bureau, à vous d'en trouver une, de la convertir au bon format, de la mettre à la même taille.

==== Les patchs ====

Les sources de l'application peuvent avoir besoin de patch, pour par exemple mieux respecter le FHS, ou pour être compatible avec des bibliothèques plus récentes.
Généralement, il faut simplement ajouer ceci :

<code>
patch < votre_fichier_patch.patch
</code>

===== Droits et permissions =====

Normalement, pkg++ le fait pour vous. Cependant, il peut arriver, notamment si les droits et permissions de l'archive source sont loin d'être standards, qu'il y ait quelques petits soucis, donc, à vous de vérifier, voire d'appliquer ceci :

<code>
cd $PKG
chown -R root:root .
find . -perm 664 -exec chmod 644 {} \;
find . -perm 600 -exec chmod 644 {} \;
find . -perm 444 -exec chmod 644 {} \;
find . -perm 400 -exec chmod 644 {} \;
find . -perm 440 -exec chmod 644 {} \;
find . -perm 777 -exec chmod 755 {} \;
find . -perm 775 -exec chmod 755 {} \;
find . -perm 511 -exec chmod 755 {} \;
find . -perm 711 -exec chmod 755 {} \;
find . -perm 555 -exec chmod 755 {} \;
</code>

Vous pouvez aussi avoir besoin de parametrer des permissions plus restrictives, comme par exemple l'accès en lecture seul pour root, et pas d'accès pour le reste. Il vous suffit d'ajouter un //chmod// dans votre build().


====== FakeRoot ======

Si vous souhaitez construire vos paquets sans risquer d'endommager votre système, il vous est possible d'utiliser fakeroot. Fakeroot lance une commande dans un environnement simulant les privilèges du super-utilisateur pour la manipulation des fichiers.\\
Vous n'avez qu'a installer le paquet disponnible dans votre distribution (ou l'empaqueter grâce à pkg++), et à lancer cette commande

  $ fakeroot pkg++ -d

Ceci construirea votre paquet, mais pkg++ -i ne fonctionnera pas car cette commande demande d'avoir les véritables droits du super-utilisateur.

====== Recettes ======

Vous pouvez vous procurer des recettes de différente manière :

  *  Par le biais des ports de [[http://crux.nu/portdb/|Crux]]
  *  de [[http://kiao.no-ip.info/NuTyX/git/|NuTyX]].

====== Construction du paquet ======

Vous avez vérifié que votre dossier de recette contien bien une arborescence comme celle ci :

<code>
appli_test/
|-Pkgfile
|-.md5sum
|-.sha256sum
|-.footprint
|-appli_test.desktop
|-appli_test.png
|-appli_test_bugfix.patch
</code>

et que le Pkgfile est bien rédigé ?
Il ne vous reste plus qu'a lancer la construction : 

  # pkg++ -d

Et patienter, suivant l'application, la compilation peut être très longue (Kernel, GCC). \\
Si la construction échoue, vérifiez bien votre Pkgfile. Si une erreur survient pendant la compilation, vérifiez que vous avez la dernière version des sources, ou cherchez un patch, sinon, soumettez un bug au développeur. \\
Si votre paquet est construit correctement (vous pouvez le tester dans un chroot vierge par exemple), la communauté de votre distribution sera ravie de l'obtenir, n'hésitez donc pas à leur en faire part.

----

//“Ce document issu de http://www.linuxpedia.fr est soumis à la licence GNU FDL consultable à l'adresse http://www.gnu.org/copyleft/fdl.html. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement.” \\
Article originial : [[http://www.linuxpedia.fr/doku.php/nutyx/regles_packages_nutyx|Faire un package NuTyX selon les règles]] //