User Tools

Site Tools


en:pkgxx

Make a pkg++ package according to the rules

Compile an application is often not much more complicated than unpack the sources and subsequently run the following commands:

# ./configure 
# make 
# make install

However, when it comes to package an application, so you can share binaries with other users, things get more complicated.

pkg++ offers a solution by allowing you to build packages as simple as possible.

Prerequisites

Here's what you need to create a pkg++ package :

  • A text editor (nano, gedit, etc.)
  • Some concepts of shell
  • pkg++
  • The dependencies of the tool you want to package

pkg++

A package is nothing more than an archive, usually with a package manager-specific extension, .rpm for RPM or .deb for dpkg for exemple, which contains all application files and the files needed for integration into distribution.
Then this package can be installed on your system with your package manager (like RPM or dpkg) and will be registered in the database of installed package.
To build a package, it is necessary to write a file, a Pkgfile for pkg++.

/etc/pkg++.conf

This configuration file is read by pkg++ before the interpretation of the Pkgfile.
Here is what it might look like:

#
# /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

We notice the CFLAGS and CXXFLAGS (optimisations) used for the compilation of the package, when it's possible.
This line: PKGMK_SOURCE_DIR=”/var/cache/pkg++/sources”, indicates where, on the system of the packager, to download sources, or where there are already downloaded, with the indication in the Pkgfile.
This line: PKGMK_PACKAGE_DIR=”/var/cache/pkg++/packages”, indicate where is located the packager's directory, which contains built packages.

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 :

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

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.

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
}

La fonction build

La fonction build est ceci :

build() {

}

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 à :

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

Voire, ceci pour une application Perl :

build() {
cd URI-$version
	perl Makefile.PL
	make
	make DESTDIR=$PKG install
}

Ou encore ceci pour une application Python :

build() {
cd $name-$version
	python setup.py build install --root=$PKG       
}

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 :

[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

Les catégories selon les standards 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 :

mkdir -p $PKG/usr/share/applications
install -m 644 ../$name.desktop $PKG/usr/share/applications/

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/48×48/apps/ (ici, taille de 48×48, 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 :

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

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 :

patch < votre_fichier_patch.patch

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 :

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 {} \;

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 :

Construction du paquet

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

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

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 : Faire un package NuTyX selon les règles

en/pkgxx.txt · Last modified: 2011/06/13 12:50 by piernov