Compiler en tant qu'utilisateur

Sur les différents forums et blogs, je vois souvent des utilisateurs qui, n’ayant pas trouvé l’application qu’il cherche dans les dépôt de leur distribution, téléchargent les sources, compilent et installent avec les commandes:

./configure
make
make install

Or je trouve certains incovénients à appliquer cette méthode sur une distribution qui dispose d’une bonne gestion de paquets/dépendances car:

  • l’emplacement des fichiers n’est pas forcément « conforme » (si on peut dire ca comme ca) à celui de la distribution.
  • on doit surveiller les mise à jour.
  • c’est peu probable, mais installer en root une application non téstée comporte des risques.
  • une désinstallation propre requiert de garder le répertoire de compilation.
  • une mise à jour de version de distribution peut échouer à cause d’une application non prise en compte par le gestionnaire de paquet.
  • et puis, je trouve ca pas bien :p (ca n’engage que moi)

Compiler sans droits root.

Du coup, je pense qu’il serait préférable d’installer les applications que ce soit pour tester (le dernier compiz, un amsn anti-aliasé, …) ou pour une utilisation temporaire dans le répertoire utilisateur de façon à les séparer du reste du système.

Pour cela, il suffit d’utiliser les options fournies par le programme configure.
Créons un répertoire qui regroupera nos applications compilées:

mkdir $HOME/prog

ensuite, il suffira d’indiquer ce répertoire à configure:

./configure --prefix=$HOME/prog

ainsi, on pourra executer:

make && make install

sans avoir besoin des droits root.

Afin de pouvoir lancer le programme compilé et installé sans aller directement dans le répertoire, on peut modifier la variable d’environnement PATH:

export PATH="$PATH:$HOME/prog/bin"

Si vous voulez donner la priorité aux applications compilées, il faut placer $HOME/prog/bin en premier.

Qu’en est il des librairies?

Certaines applications peuvent avoir besoin de librairies non présentes sur le système ou alors de la dernière version de telle ou telle librairie.
Il suffit de la compiler avec le bon prefix avant de compiler l’application. Mais lors de la compilation de l’application, la librairie ne sera pas trouvée, pour remedier à cela, il suffira de renseigner la variable d’environnement LIBRARY_PATH:

export LIBRARY_PATH=$HOME/prog/lib

gcc, entre autres, ira d’abord chercher dans les chemins déclaré dans LIBRARY_PATH.

De même, il peut être intéressant de déclarer la variable PKG_CONFIG_PATH qui permet d’indiquer à pkg-config où chercher les fichiers de déscription (.pc) des librairies qui l’utilisent:

export PKG_CONFIG="$LIBRARY_PATH/pkgconfig:$HOME/prog/share/pkgconfig"

Pouvoir récupérer la configuration.

Si vous testez (ou compilez tout simplement) les applications assez souvent, vous pouvez rajouter les déclarations dans le .bashrc (ou le fichier de démarrage de votre shell):

export PROG_PATH=$HOME/prog
export LIBRARY_PATH=$PROG_PATH/lib
export PKG_CONFIG_PATH="$LIBRARY_PATH/pkgconfig:$PROG_PATH/share/pkgconfig"
export PATH="$PATH:$PROG_PATH/bin"

Ainsi pour compiler, il suffit d’utiliser:

./configure --prefix=$PROG_PATH

Conclusion.

Je trouve qu’il est plus facile de gérer les applications tierces de cette manière, maintenant il est surement nécessaire de compléter les variables d’environnement ou d’indiquer des options supplémentaires pour le configure selon l’application, mais c’est un début.

Commentaires (2)