Manuel de référence de GNU Guix

Table des matières

Suivant: , Monter: (dir)   [Table des matières][Index]

GNU Guix

Cette documentation décrit GNU Guix version 1.2.0, un outil de gestion de paquets fonctionnel écrit pour le système GNU.

This manual is also available in Simplified Chinese (voir GNU Guix参考手册), French (voir Manuel de référence de GNU Guix), German (voir Referenzhandbuch zu GNU Guix), Spanish (voir Manual de referencia de GNU Guix), and Russian (voir Руководство GNU Guix). If you would like to translate it in your native language, consider joining Weblate.


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

1 Introduction

GNU Guix1 est un outil de gestion de paquets et une distribution pour le système GNU. Guix facilite pour les utilisateur·rice·s non privilégié·e·s l’installation, la mise à jour et la suppression de paquets, la restauration à un ensemble de paquets précédent, la construction de paquets depuis les sources et plus généralement aide à la création et à la maintenance d’environnements logiciels.

Vous pouvez installer GNU Guix sur un système GNU/Linux existant pour compléter les outils disponibles sans interférence (voir Installation) ou vous pouvez l’utiliser comme distribution système indépendante, Guix System2. Voir Distribution GNU.


Suivant: , Monter: Introduction   [Table des matières][Index]

1.1 Gérer ses logiciels avec Guix

Guix provides a command-line package management interface (voir Gestion de paquets), tools to help with software development (voir Développement), command-line utilities for more advanced usage (voir Utilitaires), as well as Scheme programming interfaces (voir Interface de programmation). Son démon de construction est responsable de la construction des paquets pour les utilisateur·rice·s (voir Paramétrer le démon) et du téléchargement des binaires pré-construits depuis les sources autorisées (voir Substituts).

Guix contient de nombreuses définitions de paquet GNU et non-GNU qui respectent tous les libertés de l’utilisateur ou utilisatrice. Il est extensible  : chacun·e peut écrire ses propres définitions de paquets (voir Définition des paquets) et les rendre disponibles dans des modules de paquets indépendants (voir Modules de paquets). Il est aussi personnalisable : on peut dériver des définitions de paquets spécialisées à partir de définitions existantes, même depuis la ligne de commande (voir Options de transformation de paquets).

Sous le capot, Guix implémente la discipline de gestion de paquet fonctionnel inventé par Nix (voir Remerciements). Dans Guix le processus de construction et d’installation des paquets est vu comme une fonction dans le sens mathématique du terme. Cette fonction a des entrées (comme des scripts de construction, un compilateur et des bibliothèques) et renvoie un paquet installé. En tant que fonction pure, son résultat ne dépend que de ses entrées. Par exemple, il ne peut pas faire référence à des logiciels ou des scripts qui n’ont pas été explicitement passés en entrée. Une fonction de construction produit toujours le même résultat quand on lui donne le même ensemble d’entrée. Elle ne peut pas modifier l’environnement du système en cours d’exécution d’aucune manière ; par exemple elle ne peut pas créer, modifier ou supprimer des fichiers en dehors de ses répertoires de construction et d’installation. Ce résultat s’obtient en lançant les processus de construction dans des environnements isolés (ou des conteneurs) où seules les entrées explicites sont visibles.

Le résultat des fonctions de construction de paquets est mis en cache dans le système de fichier, dans répertoire spécial appelé le dépôt (voir Le dépôt). Chaque paquet est installé dans son répertoire propre dans le dépôt — par défaut dans /gnu/store. Le nom du répertoire contient un hash de toutes les entrées utilisées pour construire le paquet ; ainsi, changer une entrée donnera un nom de répertoire différent.

Cette approche est le fondement des fonctionnalités les plus importante de Guix : le support des mises à jour des paquets et des retours en arrière transactionnels, l’installation différenciée par utilisateur·rice et le ramassage de miettes pour les paquets (voir Fonctionnalités).


Précédent: , Monter: Introduction   [Table des matières][Index]

1.2 Distribution GNU

Guix fournit aussi une distribution du système GNU contenant uniquement des logiciels libres3. On peut installer la distribution elle-même (voir Installation du système), mais on peut aussi installer Guix comme gestionnaire de paquets par dessus un système GNU/Linux déjà installé (voir Installation). Pour distinguer ces deux cas, on appelle la distribution autonome le « système Guix » ou Guix System.

La distribution fournit les paquets cœur de GNU comme la GNU libc, GCC et Binutils, ainsi que de nombreuses applications GNU et non-GNU. La liste complète des paquets disponibles se trouve en ligne ou en lançant guix package (voir Invoquer guix package) :

guix package --list-available

Notre but est de fournir une distribution logicielle entièrement libre de GNU/Linux et d’autres variantes de GNU, en se concentrant sur la promotion et l’intégration étroite des composants GNU en insistant sur les programmes et les outils qui aident l’utilisateur·rice à exercer ses libertés.

Les paquets sont actuellement disponibles pour les plateformes suivantes :

x86_64-linux

Intel/AMD x86_64 avec le noyau Linux-libre.

i686-linux

Architecture Intel 32 bits (IA32) avec le noyau Linux-libre.

armhf-linux

L’architecture ARMv7-A avec gestion des flottants matérielle, Thumb-2 et NEON, avec l’interface binaire applicative (ABI) EABI hard-float et le noyau Linux-libre.

aarch64-linux

les processeurs 64 bits ARMv8-A en little-endian, avec le noyau Linux-libre.

i586-gnu

GNU/Hurd sur l’architecture Intel 32-bit (IA32).

Cette configuration en cours de développement est expérimentale. La manière la plus facile pour vous de l’essayer est de créer une instance hurd-vm-service-type sur votre machine GNU/Linux (voir hurd-vm-service-type). Voir Contribuer, sur la façon d’aider !

mips64el-linux (obsolète)

little-endian 64-bit MIPS processors, specifically the Loongson series, n32 ABI, and Linux-Libre kernel. This configuration is no longer fully supported; in particular, there is no ongoing work to ensure that this architecture still works. Should someone decide they wish to revive this architecture then the code is still available.

Avec Guix System, vous déclarez tous les aspects de la configuration du système d’exploitation et guix s’occupe d’instancier la configuration de manière transactionnelle, reproductible et sans état (voir Configuration système). Guix System utilise le noyau Linux-libre, le système d’initialisation Shepherd (voir Introduction dans The GNU Shepherd Manual), les outils GNU et la chaîne d’outils familière ainsi que l’environnement graphique et les services systèmes de votre choix.

Guix System est disponible sur toutes les plateformes ci-dessus à part mips64el-linux.

Pour des informations sur comment porter vers d’autres architectures et d’autres noyau, voir Porter.

La construction de cette distribution est un effort collaboratif et nous vous invitons à nous rejoindre ! Voir Contribuer, pour des informations sur la manière de nous aider.


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

2 Installation

Remarque : Nous vous recommandons d’utiliser ce script shell d’installation pour installer Guix sur un système GNU/Linux fonctionnel, que nous appelons une distro externe4. Le script automatise le téléchargement, l’installation et la configuration initiale de Guix. Vous devez l’exécuter en tant que root.

Lorsqu’il est installé sur une distro externe, GNU Guix complète les outils disponibles sans interférence. Ses données se trouvent exclusivement dans deux répertoires, typiquement /gnu/store et /var/guix ; les autres fichiers de votre système comme /etc sont laissés intacts.

Une fois installé, Guix peut être mis à jour en lançant guix pull (voir Invoquer guix pull).

Si vous préférez effectuer les étapes d’installation manuellement ou si vous voulez les personnaliser, vous trouverez les sections suivantes utile. Elles décrivent les prérequis logiciels pour Guix, ainsi que la manière de l’installer manuellement et de se préparer à l’utiliser.


Suivant: , Monter: Installation   [Table des matières][Index]

2.1 Installation binaire

Cette section décrit comment installer Guix sur un système quelconque depuis un archive autonome qui fournit les binaires pour Guix et toutes ses dépendances. C’est souvent plus rapide que d’installer depuis les sources, ce qui est décrit dans les sections suivantes. Le seul prérequis est d’avoir GNU tar et Xz.

Remarque : Nous recommandons l’utilisation de ce script d’installation du shell. Ce script automatise les étapes de téléchargement, d’installation et de configuration initiale décrites ci-dessous. Il doit être exécuté sous l’utilisateur root. Vous pouvez donc l’exécuter en tant que root :

cd /tmp
wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
chmod +x guix-install.sh
./guix-install.sh

Lorsque vous aurez terminé, voir Réglages applicatifs pour la configuration supplémentaire dont vous pourriez avoir besoin, et Pour démarrer pour vos premiers pas !

L’installation se comme ceci :

  1. Télécharger le tarball binaire à partir de ‘https://ftp.gnu.org/gnu/guix/guix-binary-1.2.0.x86_64-linux.tar.xz’, où x86_64-linux peut être remplacé par i686-linux pour une i686 (32-bits) machine fonctionnant déjà avec le noyau Linux, et autres (voir Distribution GNU).

    Assurez-vous de télécharger le fichier .sig associé et de vérifier l’authenticité de l’archive avec, comme ceci :

    $ wget https://ftp.gnu.org/gnu/guix/guix-binary-1.2.0.x86_64-linux.tar.xz.sig
    $ gpg --verify guix-binary-1.2.0.x86_64-linux.tar.xz.sig
    
    

    Si cette commande échoue parce que vous n’avez pas la clef publique requise, lancez cette commande pour l’importer :

    $ wget https://sv.gnu.org/people/viewgpg.php?user_id=15145 \
          -qO - | gpg --import -
    

    et relancez la commande gpg --verify.

    Remarquez qu’un avertissement du type « Cette clef n’est pas certifiée par une signature de confiance ! » est normal.

  2. Maintenant, vous devez devenir root. En fonction de votre distribution, vous devrez lancer su - ou sudo -i. En tant que root, lancez :
    # cd /tmp
    # tar --warning=no-timestamp -xf \
         /chemin/vers/guix-binary-1.2.0.x86_64-linux.tar.xz
    # mv var/guix /var/ && mv gnu /
    

    Cela crée /gnu/store (voir Le dépôt) and /var/guix. Ce dernier contient un profil prêt à être utilisé pour root (voir les étapes suivantes).

    Ne décompressez pas l’archive sur un système Guix lancé car cela écraserait ses propres fichiers essentiels.

    L’option --warning=no-timestamp permet de s’assurer que GNU tar n’émet pas d’avertissements concernant des « horodatages manifestement anciens » (de tels avertissements ont été déclenchés par GNU tar 1.26 et plus anciens ; les versions récentes conviennent). Ils proviennent du fait que tous les fichiers de l’archive ont leur heure de modification fixée à un (ce qui signifie le 1er janvier 1970). Ceci est fait exprès pour s’assurer que le contenu de l’archive est indépendant de son temps de création, la rendant ainsi reproductible.

  3. Rendez le profil disponible sous ~root/.config/guix/current, qui est l’emplacement où guix pull installera les mises à jour (voir Invoquer guix pull) :
    # mkdir -p ~root/.config/guix
    # ln -sf /var/guix/profiles/per-user/root/current-guix \
             ~root/.config/guix/current
    

    Agrémentez etc/profile pour augmenter PATH et les autres variables d’environnement nécessaires :

    # GUIX_PROFILE="`echo ~root`/.config/guix/current" ; \
      source $GUIX_PROFILE/etc/profile
    
  4. Créez le groupe et les comptes utilisés pour la construction comme expliqué plus loin (voir Réglages de l'environnement de construction).
  5. Lancez le démon et paramétrez-le pour démarrer automatiquement au démarrage.

    Si votre distribution hôte utilise le système d’initialisation systemd, cela peut se faire avec ces commandes :

    # cp ~root/.config/guix/current/lib/systemd/system/gnu-store.mount \
         ~root/.config/guix/current/lib/systemd/system/guix-daemon.service \
         /etc/systemd/system/
    # systemctl enable --now gnu-store.mount guix-daemon
    

    Si votre distribution hôte utilise le système d’initialisation Upstart :

    # initctl reload-configuration
    # cp ~root/.config/guix/current/lib/upstart/system/guix-daemon.conf \
         /etc/init/
    # start guix-daemon
    

    Sinon, vous pouvez toujours démarrer le démon manuellement avec :

    # ~root/.config/guix/current/bin/guix-daemon \
           --build-users-group=guixbuild
    
  6. Rendez la commande guix disponible pour les autres personnes sur la machine, par exemple avec :
    # mkdir -p /usr/local/bin
    # cd /usr/local/bin
    # ln -s /var/guix/profiles/per-user/root/current-guix/bin/guix
    

    C’est aussi une bonne idée de rendre la version Info de ce manuel disponible ici :

    # mkdir -p /usr/local/share/info
    # cd /usr/local/share/info
    # for i in /var/guix/profiles/per-user/root/current-guix/share/info/* ;
      do ln -s $i ; done
    

    Ainsi, en supposant que /usr/local/share/info se trouve dans le chemin de recherche, l’exécution de info guix ouvrira ce manuel (voir (GNU Texinfo)texinfo, pour plus de détails sur la modification du chemin de recherche Info).

  7. Pour utiliser les substituts de ci.guix.gnu.org ou l’un de ses miroirs (voir Substituts), autorisez-les :
    # guix archive --authorize < \
         ~root/.config/guix/current/share/guix/ci.guix.gnu.org.pub
    
  8. On peut avoir besoin d’effectuer des étapes supplémentaires pour que son environnement Guix soit prêt à être utilisé, voir Réglages applicatifs.

Voilà, l’installation est terminée !

Vous pouvez confirmer que Guix fonctionne en installant un paquet d’exemple dans le profil de root :

# guix install hello

L’archive d’installation binaire peut être (re)produite et vérifiée simplement en lançant la commande suivante dans l’arborescence des sources de Guix :

make guix-binary.system.tar.xz

… ce qui à son tour lance :

guix pack -s system --localstatedir \
  --profile-name=current-guix guix

Voir Invoquer guix pack, pour plus d’info sur cet outil pratique.


Suivant: , Précédent: , Monter: Installation   [Table des matières][Index]

2.2 Prérequis

Cette section dresse la liste des prérequis pour la construction de Guix depuis les sources. La procédure de construction pour Guix est la même que pour les autres logiciels GNU, et n’est pas expliquée ici. Regardez les fichiers README et INSTALL dans l’arborescence des sources de Guix pour plus de détails.

GNU Guix est disponible au téléchargement depuis son site web sur http://www.gnu.org/software/guix/.

GNU Guix dépend des paquets suivants :

Les dépendances suivantes sont facultatives :

Sauf si --disable-daemon a été passé à configure, les paquets suivants sont également nécessaires :

Lorsque vous configurez Guix sur un système qui a déjà une installation de Guix, assurez-vous de spécifier le même répertoire d’état que l’installation existante avec l’option --localstatedir du script configure (voir localstatedir dans GNU Coding Standards). Habituellement cette option localstatedir est initialisée à /var. Le script configure vous protège des configurations involontaires de localstatedir pour éviter que vous ne corrompiez votre dépôt (voir Le dépôt).


Suivant: , Précédent: , Monter: Installation   [Table des matières][Index]

2.3 Lancer la suite de tests

Après avoir lancé configure et make correctement, c’est une bonne idée de lancer la suite de tests. Elle peut aider à trouver des erreurs avec la configuration ou l’environnement, ou des bogues dans Guix lui-même — et vraiment, rapporter des échecs de tests est une bonne manière d’aider à améliorer le logiciel. Pour lancer la suite de tests, tapez :

make check

Les cas de tests peuvent être lancés en parallèle : vous pouvez utiliser l’option -j de GNU make pour accélérer les choses. Le premier lancement peut prendre plusieurs minutes sur une machine récente ; les lancements suivants seront plus rapides car le dépôt créé pour les tests aura déjà plusieurs choses en cache.

Il est aussi possible de lancer un sous-ensemble des tests en définissant la variable makefile TESTS comme dans cet exemple :

make check TESTS="tests/store.scm tests/cpio.scm"

Par défaut, les résultats des tests sont affichés au niveau du fichier. Pour voir les détails de chaque cas de test individuel, il est possible de définir la variable makefile SCM_LOG_DRIVER_FLAGS comme dans cet exemple :

make check TESTS="tests/base64.scm" SCM_LOG_DRIVER_FLAGS="--brief=no"

The underlying SRFI 64 custom Automake test driver used for the ’check’ test suite (located at build-aux/test-driver.scm) also allows selecting which test cases to run at a finer level, via its --select and --exclude options. Here’s an example, to run all the test cases from the tests/packages.scm test file whose names start with “transaction-upgrade-entry”:

export SCM_LOG_DRIVER_FLAGS="--select=^transaction-upgrade-entry"
make check TESTS="tests/packages.scm"

Those wishing to inspect the results of failed tests directly from the command line can add the --errors-only=yes option to the SCM_LOG_DRIVER_FLAGS makefile variable and set the VERBOSE Automake makefile variable, as in:

make check SCM_LOG_DRIVER_FLAGS="--brief=no --errors-only=yes" VERBOSE=1

The --show-duration=yes option can be used to print the duration of the individual test cases, when used in combination with --brief=no:

make check SCM_LOG_DRIVER_FLAGS="--brief=no --show-duration=yes"

Voir Parallel Test Harness dans GNU Automake for more information about the Automake Parallel Test Harness.

Après un échec, envoyez un courriel à bug-guix@gnu.org et attachez le fichier test-suite.log. Précisez la version de Guix utilisée ainsi que les numéros de version de ses dépendances (voir Prérequis) dans votre message.

Guix possède aussi une suite de tests de systèmes complets qui test des instances complètes du système Guix. Elle ne peut être lancée qui sur un système où Guix est déjà installé, avec :

make check-system

ou, de nouveau, en définissant TESTS pour choisir un sous-ensemble des tests à lancer :

make check-system TESTS="basic mcron"

Ces tests systèmes sont définis dans les modules (gnu tests …). Ils fonctionnent en lançant les systèmes d’exploitation sous test avec une instrumentation légère dans une machine virtuelle (VM). Ils peuvent être intenses en terme de calculs ou plutôt rapides en fonction de la disponibilité des substituts de leurs dépendances (voir Substituts). Certains requièrent beaucoup d’espace disque pour contenir les images des VM.

De nouveau, en cas d’échec, envoyez tous les détails à bug-guix@gnu.org.


Suivant: , Précédent: , Monter: Installation   [Table des matières][Index]

2.4 Paramétrer le démon

Les opérations comme la construction d’un paquet ou le lancement du ramasse-miettes sont toutes effectuées par un processus spécialisé, le démon de construction, pour le compte des clients. Seul le démon peut accéder au dépôt et à sa base de données associée. Ainsi, toute opération manipulant le dépôt passe par le démon. Par exemple, les outils en ligne de commande comme guix package et guix build communiquent avec le démon (via des appels de procédures distantes) pour lui dire quoi faire.

Les sections suivantes expliquent comment préparer l’environnement du démon de construction. Voir aussi Substituts pour apprendre comment permettre le téléchargement de binaires pré-construits.


Suivant: , Monter: Paramétrer le démon   [Table des matières][Index]

2.4.1 Réglages de l’environnement de construction

Dans une installation standard multi-utilisateur·rice·s, Guix et son démon — le programme guix-daemon — sont installés par la personne qui administre le système ; /gnu/store appartient à root et guix-daemon est lancé en root. Les utilisateur·rice·s non-privilégié·e·s peuvent utiliser les outils Guix pour construire des paquets ou accéder au dépôt et le démon le fera pour leur compte en s’assurant que le dépôt garde un état cohérent et permet le partage des paquets déjà construits entre les utilisateur·rice·s.

Alors que guix-daemon tourne en root, vous n’avez pas forcément envie que les processus de construction de paquets tournent aussi en root, pour des raisons de sécurité évidentes. Pour éviter cela, vous devriez créer une réserve spéciale de comptes de construction que les processus de construction démarrés par le démon utiliseront. Ces comptes de construction n’ont pas besoin d’un shell ou d’un répertoire personnel ; ils seront seulement utilisés quand le démon délaissera ses privilèges root dans les processus de construction. En ayant plusieurs de ces comptes, vous permettez au démon de lancer des processus de construction distincts sous des UID différent, ce qui garanti qu’aucune interférence n’ait lieu entre les uns et les autres — une fonctionnalité essentielle puisque les constructions sont supposées être des fonctions pures (voir Introduction).

Sur un système GNU/Linux, on peut créer une réserve de comptes de construction comme ceci (avec la syntaxe Bash et les commandes shadow) :

# groupadd --system guixbuild
# for i in `seq -w 1 10`;
  do
    useradd -g guixbuild -G guixbuild           \
            -d /var/empty -s `which nologin`    \
            -c "Compte de construction Guix $i" --system    \
            guixbuilder$i;
  done

Le nombre de comptes de construction détermine le nombre de tâches de constructions qui peuvent tourner en parallèle, tel que spécifié par l’option --max-jobs (voir --max-jobs). Pour utiliser guix system vm et les commandes liées, vous devrez ajouter les comptes de construction au groupe kvm pour qu’ils puissent accéder à /dev/kvm avec -G guixbuild,kvm plutôt que -G guixbuild (voir Invoquer guix system).

Le programme guix-daemon peut ensuite être lancé en root avec la commande suivante5 :

# guix-daemon --build-users-group=guixbuild

De cette façon, le démon démarre les processus de construction dans un chroot, sous un des comptes guixbuilder. Sur GNU/Linux par défaut, l’environnement chroot ne contient rien d’autre que :

Vous pouvez influencer le répertoire où le démon stocke les arbres de construction via la variable d’environnement TMPDIR. Cependant, l’arbre de construction dans le chroot sera toujours appelé /tmp/guix-build-nom.drv-0, où nom est le nom de la dérivation — p.ex., coreutils-8.24. De cette façon, la valeur de TMPDIR ne fuite pas à l’intérieur des environnements de construction, ce qui évite des différences lorsque le processus de construction retient le nom de leur répertoire de construction.

Le démon prend en compte aussi la variable d’environnement https_proxy pour ses téléchargements HTTP et HTTPS, que ce soit pour les dérivations à sortie fixes (voir Dérivations) ou pour les substituts (voir Substituts).

Si vous installez Guix en tant qu’utilisateur·rice non privilégié·ée, il est toujours possible d’exécuter guix-daemon à condition de passer --disable-chroot. Cependant, les processus de compilation ne seront pas isolés les uns des autres, ni du reste du système. Ainsi, les processus de compilation peuvent interférer les uns avec les autres, et peuvent accéder à des programmes, des bibliothèques et d’autres fichiers disponibles sur le système - ce qui rend beaucoup plus difficile de les considérer comme des fonctions pures.


Suivant: , Précédent: , Monter: Paramétrer le démon   [Table des matières][Index]

2.4.2 Utiliser le dispositif de déchargement

Si vous le souhaitez, le démon de construction peut décharger des constructions de dérivation sur d’autres machines Guix avec le crochet de construction offload7. Lorsque cette fonctionnalité est activée, Guix lit une liste de machines de constructions spécifiée par l’utilisateur·rice dans /etc/guix/machines.scm ; à chaque fois qu’une construction est demandée, par exemple par guix build, le démon essaie de la décharger sur une des machines qui satisfont les contraintes de la dérivation, en particulier le type de système, p. ex. x86_64-linux. Une même machine peut avoir plusieurs types de systèmes, soit parce que son architecture le supporte nativement, soit par émulation (voir Émulation transparente avec QEMU), soit les deux. Les prérequis manquants pour la construction sont copiés par SSH sur la machine de construction qui procède ensuite à la construction ; si elle réussit, les sorties de la construction sont copiés vers la machine de départ. Le dispsitif de déchargement est dotée d’un scheduler de base qui tente de sélectionner la meilleure machine. La meilleure machine est choisie parmi les machines disponibles sur la base de critères tels que :

  1. La disponibilité d’un créneau de construction. Une machine de construction peut avoir autant de slots de construction (connexions) que la valeur du champ parallel-builds de son objet build-machine.
  2. Sa vitesse relative, telle que définie dans le champ speed de son objet build-machine.
  3. Sa charge. La charge normalisée de la machine doit être inférieure à une valeur seuil, configurable via le champ overload-threshold de son objet build-machine.
  4. Disponibilité de l’espace disque. Plus de 100 Mio doivent être disponibles.

Le fichier /etc/guix/machines.scm ressemble typiquement à cela :

(list (build-machine
        (name "eightysix.example.org")
        (system "x86_64-linux")
        (host-key "ssh-ed25519 AAAAC3Nza…")
        (user "bob")
        (speed 2.))     ;incroyablement rapide !

      (build-machine
        (name "armeight.example.org")
        (system "list "aarch64-linux")
        (host-key "ssh-rsa AAAAB3Nza…")
        (user "alice")
        (private-key
         (string-append (getenv "HOME")
                        "/.ssh/identity-for-guix"))))

Dans l’exemple ci-dessus nous spécifions une liste de deux machines de construction, une pour l’architecture x86_64 et i686et une pour l’architecture aarch64.

En fait, ce fichier est — et ça ne devrait pas vous surprendre ! — un fichier Scheme qui est évalué au démarrage du crochet offload. Sa valeur de retour doit être une liste d’objets build-machine. Même si cet exemple montre une liste fixée de machines de construction, on pourrait imaginer par exemple utiliser DNS-SD pour renvoyer une liste de machines de constructions potentielles découvertes sur le réseau local (voir Guile-Avahi dans Using Avahi in Guile Scheme Programs). Le type de données build-machine est détaillé plus bas.

Type de données : build-machine

Ce type de données représente les machines de construction sur lesquelles le démon peut décharger des constructions. Les champs importants sont :

name

Le nom d’hôte de la machine distante.

systèmes

Le type de système de la machine distante, p. ex., (list "x86_64-linux" "i686-linux").

user

Le compte à utiliser lors de la connexion à la machine distante par SSH. Remarquez que la paire de clef SSH ne doit pas être protégée par mot de passe pour permettre des connexions non-interactives.

host-key

Cela doit être la clef d’hôte SSH publique de la machine au format OpenSSH. Elle est utilisée pour authentifier la machine lors de la connexion. C’est une longue chaîne qui ressemble à cela :

ssh-ed25519 AAAAC3NzaC…mde+UhL hint@example.org

Si la machine utilise le démon OpenSSH, sshd, la clef d’hôte se trouve dans un fichier comme /etc/ssh/ssh_host_ed25519_key.pub.

Si la machine utilise le démon SSH de GNU lsh, la clef d’hôte est dans /etc/lsh/host-key.pub ou un fichier similaire. Elle peut être convertie au format OpenSSH avec lsh-export-key (voir Converting keys dans LSH Manual) :

$ lsh-export-key --openssh < /etc/lsh/host-key.pub
ssh-rsa AAAAB3NzaC1yc2EAAAAEOp8FoQAAAQEAs1eB46LV…

Il y a un certain nombre de champs facultatifs que vous pouvez remplir :

port (par défaut : 22)

Numéro de port du serveur SSH sur la machine.

private-key (par défaut : ~root/.ssh/id_rsa)

Le fichier de clef privée SSH à utiliser lors de la connexion à la machine, au format OpenSSH. Cette clef ne doit pas être protégée par phrase de passe.

Remarquez que la valeur par défaut est la clef privée du compte root. Assurez-vous qu’elle existe si vous utilisez la valeur par défaut.

compression (par défaut : "zlib@openssh.com,zlib")
compression-level (par défaut : 3)

Les méthodes de compression au niveau SSH et le niveau de compression demandé.

Remarquez que le déchargement utilise la compression SSH pour réduire la bande passante utilisée lors du transfert vers et depuis les machines de construction.

daemon-socket (par défaut : "/var/guix/daemon-socket/socket")

Le nom de fichier du socket Unix-domain sur lequel guix-daemon écoute sur cette machine.

overload-threshold (par défaut : 0.6)

Le seuil de charge au-dessus duquel une machine de déchargement potentielle est ignorée par le programme de déchargement. Cette valeur se traduit approximativement par l’utilisation totale du processeur de la machine de construction, allant de 0,0 (0%) à 1,0 (100%). Elle peut également être désactivée en réglant overload-threshold sur #f.

parallel-builds (par défaut : 1)

Le nombre de constructions qui peuvent tourner simultanément sur la machine.

speed (par défaut : 1.0)

Un « facteur de vitesse relatif ». L’ordonnanceur des constructions tendra à préférer les machines avec un plus grand facteur de vitesse.

features (par défaut : '())

Une liste de chaînes qui contient les fonctionnalités spécifiques supportées par la machine. Un exemple est "kvm" pour les machines qui ont le module Linux KVM et le support matériel correspondant. Les dérivations peuvent demander des fonctionnalités par leur nom et seront orchestrées sur les machines de construction correspondantes.

La commande guix doit être dans le chemin de recherche des machines de construction. Vous pouvez vérifier si c’est le cas en lançant :

ssh build-machine guix repl --version

Il reste une dernière chose à faire maintenant que machines.scm est en place. Comme expliqué ci-dessus, lors du déchargement les fichiers sont transférés entre les dépôts des machines. Pour que cela fonctionne, vous devez d’abord générer une paire de clef sur chaque machine pour permettre au démon d’exporter des archives signées des fichiers de son dépôt (voir Invoquer guix archive) :

# guix archive --generate-key

Chaque machine de construction doit autoriser la clef de la machine maîtresse pour qu’ils acceptent les éléments de dépôt de celle-ci :

# guix archive --authorize < master-public-key.txt

De même, la machine maîtresse doit autoriser les clefs de chaque machine de construction.

Toute cette histoire de clefs permet d’exprimer la confiance mutuelle deux-à-deux entre le maître et les machines de construction. Concrètement, lorsque le maître reçoit des fichiers d’une machine de construction (et vice-versa), son démon de construction s’assure qu’ils sont authentiques, n’ont pas été modifiés par un tiers et qu’il sont signés par un clef autorisée.

Pour tester que votre paramétrage fonctionne, lancez cette commande sur le nœud maître :

# guix offload test

This will attempt to connect to each of the build machines specified in /etc/guix/machines.scm, make sure Guix is available on each machine, attempt to export to the machine and import from it, and report any error in the process.

Si vous souhaitez tester un fichier de machines différent, spécifiez-le sur la ligne de commande :

# guix offload test machines-qualif.scm

Enfin, vous pouvez tester un sous-ensemble de machines dont le nom correspond à une expression rationnelle comme ceci :

# guix offload test machines.scm '\.gnu\.org$'

Pour afficher la charge actuelle de tous les hôtes de construction, lancez cette commande sur le nœud principal :

# guix offload status

Précédent: , Monter: Paramétrer le démon   [Table des matières][Index]

2.4.3 Support de SELinux

Guix inclus un fichier de politique SELinux dans etc/guix-daemon.cil qui peut être installé sur un système où SELinux est activé pour que les fichiers Guix soient étiquetés et pour spécifier le comportement attendu du démon. Comme Guix System ne fournit pas de politique SELinux de base, la politique du démon ne peut pas être utilisée sur le système Guix.

2.4.3.1 Installer la politique SELinux

Pour installer la politique, lancez cette commande en root :

semodule -i etc/guix-daemon.cil

Puis ré-étiquetez le système de fichier avec restorecon ou par un mécanisme différent fournit par votre système.

Une fois la politique installée, le système de fichier ré-étiqueté et le démon redémarré, il devrait être lancé dans le contexte guix_daemon_t. Vous pouvez le confirmer avec la commande suivante :

ps -Zax | grep guix-daemon

Surveillez les fichiers journaux de SELinux pendant que vous lancez une commande comme guix build hello pour vous convaincre que SELniux permet toutes les opérations nécessaires.

2.4.3.2 Limitations

La politique n’est pas parfaite. Voici une liste de limitations et de bizarreries qui vous devriez prendre en compte avant de déployer la politique SELinux fournie pour le démon Guix.

  1. guix_daemon_socket_t n’est pas vraiment utilisé. Aucune des opérations sur les sockets n’impliquent de contextes qui ont quoi que ce soit à voir avec guix_daemon_socket_t. Ça ne fait pas de mal d’avoir une étiquette inutilisée, mais il serait préférable de définir des règles sur les sockets uniquement pour cette étiquette.
  2. guix gc ne peut pas accéder à n’importe quel lien vers les profils. Par conception, l’étiquette de fichier de la destination d’un lien symbolique est indépendant de l’étiquette du lien lui-même. Bien que tous les profils sous $localstatedir aient une étiquette, les liens vers ces profils héritent de l’étiquette du répertoire dans lequel ils se trouvent. Pour les liens dans le répertoire personnel cela sera user_home_t. Mais pour les liens du répertoire personnel de root, ou /tmp, ou du répertoire de travail du serveur HTTP, etc, cela ne fonctionnera pas. SELinux empêcherait guix gc de lire et de suivre ces liens.
  3. La fonctionnalité du démon d’écouter des connexions TCP pourrait ne plus fonctionner. Cela demande des règles supplémentaires car SELinux traite les sockets réseau différemment des fichiers.
  4. Actuellement tous les fichiers qui correspondent à l’expression rationnelle /gnu/store/.+-(guix-.+|profile)/bin/guix-daemon reçoivent l’étiquette guix_daemon_exec_t ; cela signifie que tout fichier avec ce nom dans n’importe quel profil serait autorisé à se lancer dans le domaine guix_daemon_t. Ce n’est pas idéal. Un attaquant pourrait construire un paquet qui fournit cet exécutable et convaincre un·e utilisateur·rice de l’installer et de le lancer, ce qui l’élève dans le domaine guix_daemon_t. À ce moment SELinux ne pourrait pas l’empêcher d’accéder à des fichiers autorisés pour les processus de ce domaine.

    You will need to relabel the store directory after all upgrades to guix-daemon, such as after running guix pull. Assuming the store is in /gnu, you can do this with restorecon -vR /gnu, or by other means provided by your operating system.

    Nous pourrions générer une politique bien plus restrictive à l’installation, pour que seuls les noms de fichiers exacts de l’exécutable guix-daemon actuellement installé soit étiqueté avec guix_daemon_exec_t, plutôt que d’utiliser une expression rationnelle plus large. L’inconvénient c’est que root devrait installer ou mettre à jour la politique à l’installation à chaque fois que le paquet Guix qui fournit l’exécutable guix-daemon effectivement exécuté est mis à jour.


Suivant: , Précédent: , Monter: Installation   [Table des matières][Index]

2.5 Invoquer guix-daemon

Le programme guix-daemon implémente toutes les fonctionnalités d’accès au dépôt. Cela inclus le lancement des processus de construction, le lancement du ramasse-miettes, la demande de disponibilité des résultats de construction, etc. Il tourne normalement en root comme ceci :

# guix-daemon --build-users-group=guixbuild

Pour des détails sur son paramétrage, voir Paramétrer le démon.

Par défaut, guix-daemon lance les processus de construction sous différents UIDs récupérés depuis le groupe de construction spécifié avec --build-users-group. En plus, chaque processus de construction est lancé dans un environnement chroot qui ne contient que le sous-ensemble du dépôt dont le processus de construction dépend, tel que spécifié par sa dérivation (voir dérivation), plus un ensemble de répertoires systèmes spécifiques. Par défaut ce dernier contient /dev et /dev/pts. De plus, sous GNU/Linux, l’environnement de construction est un conteneur : en plus d’avoir sa propre arborescence du système de fichier, il a un espace de nom de montage séparé, son propre espace de nom PID, son espace de nom de réseau, etc. Cela aide à obtenir des constructions reproductibles (voir Fonctionnalités).

Lorsque le démon effectue une construction pour le compte de l’utilisateur·rice, il crée un répertoire de construction sous /tmp ou sous le répertoire spécifié par sa variable d’environnement TMPDIR. Ce répertoire est partagé avec le conteneur pendant toute la durée de la construction, bien que dans le conteneur, l’arbre de compilation soit toujours appelé /tmp/guix-build-name.drv-0.

Le répertoire de construction est automatiquement supprimé à la fin, à moins que la construction n’ait échoué et que le client ait spécifié --keep-failed (voir --keep-failed).

Le démon écoute les connexions et démarre un sous-processus pour chaque session démarrée par un client (l’une des sous-commandes de guix). La commande guix processes vous permet d’obtenir un aperçu de l’activité sur votre système en affichant chaque session et client actifs. Voir Invoquer guix processes pour plus d’informations.

Les options en ligne de commande suivantes sont disponibles :

--build-users-group=groupe

Utiliser les comptes du groupe pour lancer les processus de construction (voir comptes de construction).

--no-substitutes

Ne pas utiliser de substitut pour les résultats de la construction. C’est-à-dire, toujours construire localement plutôt que de permettre le téléchargement de binaires pré-construits (voir Substituts).

Lorsque le démon est lancé avec --no-substitutes, les clients peuvent toujours activer explicitement la substitution via l’appel de procédure distante set-build-options (voir Le dépôt).

--substitute-urls=urls

Considérer urls comme la liste séparée par des espaces des URL des sources de substituts par défaut. Lorsque cette option est omise, ‘https://ci.guix.gnu.org’ est utilisé.

Cela signifie que les substituts sont téléchargés depuis les urls, tant qu’ils sont signés par une signature de confiance (voir Substituts).

Voir Récupérer des substituts d'autres serveurs, pour plus d’information sur la configuration du démon pour récupérer des substituts d’autres serveurs.

--no-offload

N’essaye pas de décharger les constructions vers d’autres machines (voir Réglages du délestage du démon). C’est-à-dire que tout sera construit localement au lieu de décharger les constructions à une machine distante.

--cache-failures

Mettre les échecs de construction en cache. Par défaut, seules les constructions réussies sont mises en cache.

Lorsque cette option est utilisée, guix gc --list-failures peut être utilisé pour demander l’ensemble des éléments du dépôt marqués comme échoués ; guix gc --clear-failures vide la liste des éléments aillant échoué. Voir Invoquer guix gc.

--cores=n
-c n

Utiliser n cœurs CPU pour construire chaque dérivation ; 0 signifie autant que possible.

La valeur par défaut est 0, mais elle peut être annulée par les clients, comme avec l’option --cores de guix build (voir Invoquer guix build).

L’effet est de définir la variable d’environnement NIX_BUILD_CORES dans le processus de construction, qui peut ensuite l’utiliser pour exploiter le parallélisme en interne — par exemple en lançant make -j$NIX_BUILD_CORES.

--max-jobs=n
-M n

Permettre au plus n travaux de construction en parallèle. La valeur par défaut est 1. La mettre à 0 signifie qu’aucune construction ne sera effectuée localement ; à la place, le démon déchargera les constructions (voir Réglages du délestage du démon) ou échouera.

--max-silent-time=secondes

Lorsque le processus de construction ou de substitution restent silencieux pendant plus de secondes, le terminer et rapporter une erreur de construction.

La valeur par défaut est 0, ce qui désactive le délai.

La valeur spécifiée ici peut être annulée par les clients (voir --max-silent-time).

--timeout=secondes

De même, lorsque le processus de construction ou de substitution dure plus de secondes, le terminer et rapporter une erreur de construction.

La valeur par défaut est 0, ce qui désactive le délai.

La valeur spécifiée ici peut être annulée par les clients (voir --timeout).

--rounds=N

Construire chaque dérivations N fois à la suite, et lever une erreur si les résultats de construction consécutifs ne sont pas identiques bit-à-bit. Remarquez que ce paramètre peut être modifié par les clients comme guix build (voir Invoquer guix build).

Lorsqu’utilisé avec --keep-failed, la sortie différente est gardée dans le dépôt sous /gnu/store/…-check. Cela rend plus facile l’étude des différences entre les deux résultats.

--debug

Produire une sortie de débogage.

Cela est utile pour déboguer des problèmes de démarrage du démon, mais ensuite elle peut être annulée par les clients, par exemple par l’option --verbosity de guix build (voir Invoquer guix build).

--chroot-directory=rép

Ajouter rép au chroot de construction.

Cela peut changer le résultat d’un processus de construction — par exemple s’il utilise une dépendance facultative trouvée dans rép lorsqu’elle est disponible ou pas sinon. Pour cette raison, il n’est pas recommandé d’utiliser cette option. À la place, assurez-vous que chaque dérivation déclare toutes les entrées dont elle a besoin.

--disable-chroot

Désactive les constructions dans un chroot.

Utiliser cette option n’est pas recommandé car, de nouveau, elle permet aux processus de construction d’accéder à des dépendances non déclarées. Elle est nécessaire cependant lorsque guix-daemon tourne sans privilèges.

--log-compression=type

Compresser les journaux de construction suivant le type, parmi gzip, bzip2 ou none.

À moins que --lose-logs ne soit utilisé, tous les journaux de construction sont gardés dans localstatedir. Pour gagner de la place, le démon les compresse automatiquement avec bzip2 par défaut.

--discover[=yes|no]

Whether to discover substitute servers on the local network using mDNS and DNS-SD.

This feature is still experimental. However, here are a few considerations.

  1. It might be faster/less expensive than fetching from remote servers;
  2. There are no security risks, only genuine substitutes will be used (voir Authentification des substituts);
  3. An attacker advertising guix publish on your LAN cannot serve you malicious binaries, but they can learn what software you’re installing;
  4. Servers may serve substitute over HTTP, unencrypted, so anyone on the LAN can see what software you’re installing.

It is also possible to enable or disable substitute server discovery at run-time by running:

herd discover guix-daemon on
herd discover guix-daemon off
--disable-deduplication

Désactiver la « déduplication » automatique des fichiers dans le dépôt.

Par défaut, les fichiers ajoutés au dépôt sont automatiquement « dédupliqués » : si un nouveau fichier est identique à un autre fichier trouvé dans le dépôt, le démon en fait un lien en dur vers l’autre fichier. Cela réduit considérablement l’utilisation de l’espace disque au prix d’une charge en entrée/sortie plus grande à la fin d’un processus de construction. Cette option désactive cette optimisation.

--gc-keep-outputs[=yes|no]

Dire si le ramasse-miettes (GC) doit garder les sorties des dérivations utilisées.

Lorsqu’il est réglé sur yes, le GC conservera les sorties de toute dérivation active disponibles dans le dépôt—les fichiers .drv. La valeur par défaut est no, ce qui signifie que les sorties des dérivations ne sont conservées que si elles sont accessibles à partir d’une racine GC. Voir Invoquer guix gc, pour en savoir plus sur les racines GC.

--gc-keep-derivations[=yes|no]

Dire si le ramasse-miettes (GC) doit garder les dérivations correspondant à des sorties utilisées.

Lorsqu’il est réglé à « yes », comme c’est le cas par défaut, le GC garde les dérivations — c.-à-d. les fichiers .drv — tant qu’au moins une de leurs sorties est utilisée. Cela permet de garder une trace de l’origine des éléments du dépôt. Le mettre à no préserve un peu d’espace disque.

De cette manière, le réglage de l’option --gc-keep-derivations sur yes étend le résultat des sorties aux dérivations, et le réglage de l’option --gc-keep-outputs sur yes étend le résultat des dérivations aux sorties. Lorsque les deux sont réglés sur yes, l’effet est de conserver tous les prérequis de construction (les sources, le compilateur, les bibliothèques et autres outils de construction) des objets actifs dans le dépôt, que ces prérequis soient accessibles ou non depuis une racine GC. Cela est pratique pour les développeurs car cela permet d’éviter les reconstructions ou les téléchargements.

--impersonate-linux-2.6

Sur les systèmes basés sur Linux, imiter Linux 2.6. Cela signifie que l’appel système uname du noyau indiquera 2.6 comme numéro de version.

Cela peut être utile pour construire des programmes qui dépendent (généralement sans fondement) du numéro de version du noyau.

--lose-logs

Ne pas garder les journaux de construction. Par défaut ils sont gardés dans localstatedir/guix/log.

--system=système

Supposer que système est le type de système actuel. Par défaut c’est la paire architecture-noyau trouvée à la configuration, comme x86_64-linux.

--listen=extrémité

Écouter les connexions sur extrémité. extrémité est interprété comme un nom de fichier d’un socket Unix-domain s’il commence par / (barre oblique). Sinon, extrémité est interprété comme un nom de domaine ou d’hôte et un port sur lequel écouter. Voici quelques exemples :

--listen=/gnu/var/daemon

Écouter les connexions sur le socket Unix-domain /gnu/var/daemon en le créant si besoin.

--listen=localhost

Écouter les connexions TCP sur l’interface réseau correspondant à localhost sur le port 44146.

--listen=128.0.0.42:1234

Écouter les connexions TCP sur l’interface réseau correspondant à 128.0.0.42 sur le port 1234.

Cette option peut être répétée plusieurs fois, auquel cas guix-daemon accepte des connexions sur tous les paramètres spécifiés. On peut indiquer aux commandes clientes à quoi se connecter en paramétrant la variable d’environnement GUIX_DAEMON_SOCKET (voir GUIX_DAEMON_SOCKET).

Remarque : Le protocole du démon est non authentifié et non chiffré. Utiliser --listen=host est adapté sur des réseaux locaux, comme pour des grappes de serveurs, où seuls des nœuds de confiance peuvent se connecter au démon de construction. Dans les autres cas où l’accès à distance au démon est requis, nous conseillons d’utiliser un socket Unix-domain avec SSH.

Lorsque --listen est omis, guix-daemon écoute les connexions sur le socket Unix-domain situé à localstatedir/guix/daemon-socket/socket.


Suivant: , Précédent: , Monter: Installation   [Table des matières][Index]

2.6 Réglages applicatifs

Lorsque vous utilisez Guix par dessus une distribution GNU/Linux qui n’est pas Guix System — ce qu’on appelle une distro externe — quelques étapes supplémentaires sont requises pour que tout soit en place. En voici certaines.

2.6.1 Régionalisation

Les paquets installés via Guix n’utiliseront pas les données de régionalisation du système hôte. À la place, vous devrez d’abord installer l’un des paquets linguistiques disponibles dans Guix puis définir la variable d’environnement GUIX_LOCPATH :

$ guix install glibc-locales
$ export GUIX_LOCPATH=$HOME/.guix-profile/lib/locale

Note that the glibc-locales package contains data for all the locales supported by the GNU libc and weighs in at around 917 MiB. Alternatively, the glibc-utf8-locales is smaller but limited to a few UTF-8 locales.

La variable GUIX_LOCPATH joue un rôle similaire à LOCPATH (voir LOCPATH dans The GNU C Library Reference Manual). Il y a deux différences importantes cependant :

  1. GUIX_LOCPATH n’est compris que par la libc dans Guix et pas par la libc fournie par les distros externes. Ainsi, utiliser GUIX_LOCPATH vous permet de vous assurer que les programmes de la distro externe ne chargeront pas de données linguistiques incompatibles.
  2. la libc ajoute un suffixe /X.Y à chaque entrée de GUIX_LOCPATH, où X.Y est la version de la libc — p. ex. 2.22. Cela signifie que, si votre profile Guix contient un mélange de programmes liés avec des versions différentes de la libc, chaque version de la libc essaiera de charger les environnements linguistiques dans le bon format.

Cela est important car le format des données linguistiques utilisés par différentes version de la libc peuvent être incompatibles.

2.6.2 Name Service Switch

Lorsque vous utilisez Guix sur une distro externe, nous recommandons fortement que ce système fasse tourner le démon de cache de service de noms de la bibliothèque C de GNU, nscd, qui devrait écouter sur le socket /var/run/nscd/socket. Sans cela, les applications installées avec Guix peuvent échouer à résoudre des noms d’hôtes ou de comptes, ou même planter. Les paragraphes suivants expliquent pourquoi.

La bibliothèque C de GNU implémente un name service switch (NSS), qui est un mécanisme d’extension pour les « résolutions de noms » en général : résolution de nom d’hôte, de compte utilisateur·rice et plus (voir Name Service Switch dans The GNU C Library Reference Manual).

Comme il est extensible, NSS supporte des greffons qui fournissent une nouvelle implémentation de résolution de nom : par exemple le greffon nss-mdns permet la résolution de noms d’hôtes en .local, le greffon nis permet la résolution de comptes avec le Network Information Service (NIS), etc. Ces « services de recherches » supplémentaires sont configurés au niveau du système dans /etc/nsswitch.conf, et tous les programmes qui tournent sur ce système honorent ces paramètres (voir NSS Configuration File dans The GNU C Reference Manual)

Lorsqu’ils essayent d’effectuer une résolution de nom — par exemple en appelant la fonction getaddrinfo en C — les applications essayent d’abord de se connecter au nscd ; en cas de réussite, nscd effectue la résolution de nom pour eux. Si le nscd ne tourne pas, alors ils effectuent la résolution eux-mêmes, en changeant les service de résolution dans leur propre espace d’adressage et en le lançant. Ce services de résolution de noms — les fichiers libnns_*.so — sont dlopenés mais ils peuvent provenir de la bibliothèque C du système, plutôt que de la bibliothèque C à laquelle l’application est liée (la bibliothèque C de Guix).

Et c’est là que se trouve le problème : si votre application est liée à la bibliothèque C de Guix (disons, glibc-2.24) et essaye de charger les greffons NSS d’une autre bibliothèque C (disons, libnss_mdns.so pour glibc-2.22), il est très probable qu’elle plante ou que sa résolution de nom échoue de manière inattendue.

Lancer nscd sur le système, entre autres avantages, élimine ce problème d’incompatibilité binaire car ces fichiers libnss_*.so sont chargés par le processus nscd, pas par l’application elle-même.

2.6.3 Polices X11

La majorité des applications graphiques utilisent fontconfig pour trouver et charger les polices et effectuer le rendu côté client X11. Le paquet fontconfig dans Guix cherche les polices dans $HOME/.guix-profile par défaut. Ainsi, pour permettre aux applications graphiques installées avec Guix d’afficher des polices, vous devez aussi installer des polices avec Guix. Les paquets de polices essentiels sont gs-fonts, font-dejavu et font-gnu-freefont-ttf.

Lorsque vous installez ou supprimez des polices, ou lorsque vous remarquez qu’une application ne trouve pas les polices, vous pouvez avoir besoin d’installer Fontconfig et de forcer un rafraîchissement de son cache de police avec :

guix install fontconfig
fc-cache -rv

Pour afficher des textes écrits en chinois, en japonais ou en coréen dans les applications graphiques, installez font-adobe-source-han-sans ou font-wqy-zenhei. Le premier a plusieurs sorties, une par famille de langue (voir Des paquets avec plusieurs résultats). Par exemple, la commande suivante installe les polices pour le chinois :

guix install font-adobe-source-han-sans:cn

Les vieux programmes comme xterm n’utilisent pas fontconfig et s’appuient sur le rendu du côté du serveur. Ces programmes ont besoin de spécifier le nom complet de la police en utilisant XLFD (X Logical Font Description), comme ceci :

-*-dejavu sans-medium-r-normal-*-*-100-*-*-*-*-*-1

Pour pouvoir utiliser ces noms complets avec les polices TrueType installées dans votre profil Guix, vous devez étendre le chemin des polices du serveur X :

xset +fp $(dirname $(readlink -f ~/.guix-profile/share/fonts/truetype/fonts.dir))

Ensuite, vous pouvez lancer xlsfonts (du paquet xlsfonts) pour vous assurer que vos polices TrueType y sont listées.

2.6.4 Certificats X.509

Le paquet nss-certs fournit les certificats X.509 qui permettent aux programmes d’authentifier les serveurs web par HTTPS.

Lorsque vous utilisez Guix sur une distribution externe, vous pouvez installer ce paquet et définir les variables d’environnement adéquates pour que les paquets sachent où trouver les certificats. Voir Certificats X.509, pour des informations détaillées.

2.6.5 Paquets emacs

Quand vous installez des paquets Emacs avec Guix, les fichiers Elips sont placés dans le répertoire share/emacs/site-lisp/ du profil dans lequel ils sont installés. Les bibliothèques Elisp sont rendues disponibles dans Emacs avec la variable d’environnement EMACSLOADPATH, qui est initialisée à l’installation d’Emacs lui-même.

En plus, des définitions autoload sont automatiquement évaluées au démarrage d’Emacs, par la procédure guix-emacs-autoload-packages de Guix. Si, pour quelque raison que ce soit, vous souhaitez éviter de charger automatiquement les paquets Emacs installés avec Guix, vous pouvez le faire en lançant Emacs avec l’option --no-site-file (voir Init File dans The GNU Emacs Manual).


Précédent: , Monter: Installation   [Table des matières][Index]

2.7 Mettre à niveau Guix

Pour mettre Guix à niveau, lancez :

guix pull

Voir Invoquer guix pull, pour plus d’informations.

Sur une distribution externe, vous pouvez mettre à jour le démon de construction en lançant :

sudo -i guix pull

suivi de (dans le cas où votre distribution utilise l’outil de gestion de services Systemd) :

systemctl restart guix-daemon.service

Sur Guix System, la mise à jour du démon est effectuée par la reconfiguration du système (voir guix system reconfigure).


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

3 Installation du système

Cette section explique comment installer Guix System sur une machine. Guix, en tant que gestionnaire de paquets, peut aussi être installé sur un système GNU/Linux déjà installé, voir Installation.


Suivant: , Monter: Installation du système   [Table des matières][Index]

3.1 Limitations

Nous considérons Guix System comme prêt pour une grande variété de cas d’utilisation pour le « bureau » et le serveur. Les garantis de fiabilité qu’il fournit — les mises à jour transactionnelles, les retours en arrières et la reproductibilité — en font une solide fondation.

Néanmoins, avant de procéder à l’installation, soyez conscient de ces limitations les plus importantes qui s’appliquent à la version 1.2.0 :

Plus qu’un avertissement, c’est une invitation à rapporter les problèmes (et vos succès !) et à nous rejoindre pour améliorer la distribution. Voir Contribuer, pour plus d’info.


Suivant: , Précédent: , Monter: Installation du système   [Table des matières][Index]

3.2 Considérations matérielles

GNU Guix se concentre sur le respect des libertés de ses utilisateurs et utilisatrices. Il est construit autour du noyau Linux-libre, ce qui signifie que seuls les matériels pour lesquels des pilotes logiciels et des microgiciels libres sont disponibles sont pris en charge. De nos jours, une grande gamme de matériel qu’on peut acheter est prise en charge par GNU/Linux-libre — des claviers aux cartes graphiques en passant par les scanners et les contrôleurs Ethernet. Malheureusement, il reste des produits dont les fabricants refusent de laisser le contrôle aux utilisateur·rice·s sur leur propre utilisation de l’ordinateur, et ces matériels ne sont pas pris en charge par Guix System.

L’un des types de matériels où les pilotes ou les microgiciels sont le moins disponibles sont les appareils WiFi. Les appareils WiFi connus pour fonctionner sont ceux qui utilisent des puces Atheros (AR9271 et AR7010) qui correspondent au pilote ath9k de Linux-libre, et ceux qui utilisent des puces Broadcom/AirForce (BCM43xx avec la révision Wireless-Core 5), qui correspondent au pilote b43-open de Linux-libre. Des microgiciels libres existent pour les deux et sont disponibles directement sur Guix System, dans %base-firmware (voir firmware).

La Free Software Foundation a un programme de certification nommé Respects Your Freedom (RYF), pour les produits matériels qui respectent votre liberté et votre vie privée en s’assurant que vous avez le contrôle sur l’appareil. Nous vous encourageons à vérifier la liste des appareils certifiés par RYF.

Une autre ressource utile est le site web H-Node. Il contient un catalogue d’appareils avec des informations sur leur support dans GNU/Linux.


Suivant: , Précédent: , Monter: Installation du système   [Table des matières][Index]

3.3 Installation depuis une clef USB ou un DVD

Une image d’installation ISO-9660 qui peut être écrite sur une clé USB ou être gravée sur un DVD est téléchargeable à partir de ‘https://ftp.gnu.org/gnu/guix/guix-system-install-1.2.0.x86_64-linux.iso.xz’, où vous pouvez remplacer x86_64-linux par l’un des éléments suivants :

x86_64-linux

pour un système GNU/Linux sur un CPU compatible Intel/AMD 64-bits ;

i686-linux

pour un système GNU/Linux sur un CPU compatible Intel 32-bits.

Assurez-vous de télécharger les fichiers .sig associés et de vérifier l’authenticité de l’image avec, de cette manière :

$ wget https://ftp.gnu.org/gnu/guix/guix-system-install-1.2.0.x86_64-linux.iso.xz.sig
$ gpg --verify guix-system-install-1.2.0.x86_64-linux.iso.xz.sig

Si cette commande échoue parce que vous n’avez pas la clef publique requise, lancez cette commande pour l’importer :

$ wget https://sv.gnu.org/people/viewgpg.php?user_id=15145 \
      -qO - | gpg --import -

et relancez la commande gpg --verify.

Remarquez qu’un avertissement du type « Cette clef n’est pas certifiée par une signature de confiance ! » est normal.

Cette image contient les outils nécessaires à l’installation. Elle est faite pour être copiée telle quelle sur une clef USB assez grosse ou un DVD.

Copie sur une clef USB

Pour copier l’image sur une clef USB, suivez ces étapes :

  1. Décompressez l’image avec la commande xz :
    xz -d guix-system-install-1.2.0.x86_64-linux.iso.xz
    
  2. Insérez la clef USB de 1 Gio ou plus dans votre machine et déterminez son nom d’appareil. En supposant que la clef usb est connue sous le nom de /dev/sdX, copiez l’image avec :
    dd if=guix-system-install-1.2.0.x86_64-linux.iso of=/dev/sdX status=progress
    sync
    

    Accéder à /dev/sdX requiert généralement les privilèges d’administration.

Graver sur un DVD

Pour copier l’image sur un DVD, suivez ces étapes :

  1. Décompressez l’image avec la commande xz :
    xz -d guix-system-install-1.2.0.x86_64-linux.iso.xz
    
  2. Insérez un DVD vierge dans votre machine et déterminez son nom d’appareil. En supposant que le DVD soit connu sont le nom de /dev/srX, copiez l’image avec :
    growisofs -dvd-compat -Z /dev/srX=guix-system-install-1.2.0.x86_64-linux.iso
    

    Accéder à /dev/srX requiert généralement les privilèges root.

Démarrage

Once this is done, you should be able to reboot the system and boot from the USB stick or DVD. The latter usually requires you to get in the BIOS or UEFI boot menu, where you can choose to boot from the USB stick. In order to boot from Libreboot, switch to the command mode by pressing the c key and type search_grub usb.

Voir Installer Guix dans une VM, si, à la place, vous souhaitez installer Guix System dans une machine virtuelle (VM).


Suivant: , Précédent: , Monter: Installation du système   [Table des matières][Index]

3.4 Préparer l’installation

Une fois que vous avez démarré, vous pouvez utiliser l’installateur graphique, qui rend facile la prise en main (voir Installation graphique guidée). Sinon, si vous êtes déjà familier avec GNU/Linux et que vous voulez plus de contrôle que ce que l’installateur graphique propose, vous pouvez choisir le processus d’installation « manuel » (voir Installation manuelle).

L’installateur graphique est disponible sur le TTY1. Vous pouvez obtenir des shells root sur les TTY 3 à 6 en tapant ctrl-alt-f3, ctrl-alt-f4 etc. Le TTY2 affiche cette documentation que vous pouvez atteindre avec ctrl-alt-f2. On peut naviguer dans la documentation avec les commandes du lecteur Info (voir Stand-alone GNU Info). Le démon de souris GPM tourne sur le système d’installation, ce qui vous permet de sélectionner du texte avec le bouton gauche de la souris et de le coller en appuyant sur la molette.

Remarque : L’installation nécessite un accès au réseau pour que les dépendances manquantes de votre configuration système puissent être téléchargées. Voyez la section « réseau » plus bas.


Suivant: , Précédent: , Monter: Installation du système   [Table des matières][Index]

3.5 Installation graphique guidée

L’installateur graphique est une interface utilisateur en mode texte. Il vous guidera, avec des boîtes de dialogue, le long des étapes requises pour installer GNU Guix System.

La première boîte de dialogue vous permet de paramétrer le système comme vous le souhaitez pendant l’installation : vous pouvez choisir la langue, la disposition du clavier et paramétrer le réseau, qui sera utilisé pendant l’installation. L’image ci-dessous montre le dialogue pour le réseau.

paramétrage du réseau avec
l’installateur graphique

Les étapes suivantes vous permettent de partitionner votre disque dur, comme le montre l’image ci-dessous, de choisir si vous voulez ou non utiliser des systèmes de fichiers chiffrés, de saisir le nom d’hôte et le mot de passe root et de créer un compte supplémentaire, entre autres choses.

partitionnement du disque avec
l’installateur graphique

Remarquez que, à tout moment, l’installateur vous permet de sortir de l’étape d’installation actuelle et de recommencer une étape précédente, comme le montre l’image ci-dessous.

reprise du processus d’installation

Une fois que vous avez fini, l’installateur produit une configuration de système d’exploitation et vous la montre (voir Utiliser le système de configuration). À ce moment, vous pouvez appuyer sur « OK » et l’installation continuera. Lorsqu’elle aura réussi, vous pourrez redémarrer sur le nouveau système et vous amuser. Voir Après l'installation du système, pour la suite des festivités !


Suivant: , Précédent: , Monter: Installation du système   [Table des matières][Index]

3.6 Installation manuelle

Cette section décrit comme vous pourriez installe « manuellement » GNU Guix System sur votre machine. Cette option nécessite que vous soyez familier avec GNU/Linux, le shell et avec les outils d’administration usuels. Si vous pensez que ce n’est pas pour vous, pensez à utiliser l’installateur graphique (voir Installation graphique guidée).

Le système d’installation fournit des shells root sur les TTY 3 à 6 ; appuyez sur ctrl-alt-f3, ctrl-alt-f4 etc pour y accéder. Il inclus plusieurs outils usuels pour requis pour cette tâche. Mais c’est aussi un système Guix complet, ce qui signifie que vous pouvez installer des paquets supplémentaires si vous en avez besoin, avec guix package (voir Invoquer guix package).


Suivant: , Monter: Installation manuelle   [Table des matières][Index]

3.6.1 Disposition du clavier réseau et partitionnement

Avant que vous ne puissiez installer le système, vous voudrez sans doute ajuster la disposition du clavier, paramétrer le réseau et partitionner le disque dur cible. Cette section vous guidera à travers tout cela.

3.6.1.1 Disposition du clavier

L’image d’installation utilise la disposition clavier qwerty (US). Si vous voulez la changer, vous pouvez utiliser la commande loadkeys. Par exemple, la commande suivante sélectionne la disposition Dvorak :

loadkeys dvorak

Consultez les fichiers dans /run/current-system/profile/share/keymaps pour trouver une liste des dispositions disponibles. Lancez man loadkey pour plus d’informations.

3.6.1.2 Réseau

Lancez la commande suivante pour voir comment vos interfaces réseau sont appelées :

ifconfig -a

… ou, avec la commande spécifique à GNU/Linux ip :

ip address

Les interfaces filaires ont un nom qui commence par ‘e’ ; par exemple, l’interface qui correspond au premier contrôleur Ethernet sur la carte mère est appelé ‘eno1’. Les interfaces sans-fil ont un nom qui commence par ‘w’, comme ‘w1p2s0’.

Connexion filaire

Pour configure une connexion filaire, lancez la commande suivante, en remplaçant interface par le nom de l’interface filaire que vous voulez utiliser.

ifconfig interface up

… ou, avec la commande spécifique à GNU/Linux ip :

ip link set interface up
Connexion sans-fil

Pour configurer le réseau sans-fil, vous pouvez créer un fichier de configuration pour l’outil de configuration wpa_supplicant (son emplacement importe peu) avec l’un des éditeurs de texte disponibles comme nano :

nano wpa_supplicant.conf

Par exemple, la déclaration qui suit peut aller dans ce fichier et fonctionnera pour plusieurs réseaux sans-fil, si vous donnez le vrai SSID et la phrase de passe pour le réseau auquel vous vous connectez :

network={
  ssid="mon-ssid"
  key_mgmt=WPA-PSK
  psk="la phrase de passe secrète du réseau"
}

Démarrez le service sans-fil et lancez-le en tache de fond avec la commande suivante (en remplaçant interface par le nom de l’interface réseau que vous voulez utiliser) :

wpa_supplicant -c wpa_supplicant.conf -i interface -B

Lancez man wpa_supplicant pour plus d’informations.

À partir de ce moment, vous avez besoin d’une adresse IP. Sur les réseaux où les IP sont automatiquement attribuée par DHCP, vous pouvez lancer :

dhclient -v interface

Essayez de pinger un serveur pour voir si le réseau fonctionne :

ping -c 3 gnu.org

Mettre en place un accès réseau est presque toujours une nécessité parce que l’image ne contient pas tous les logiciels et les outils dont vous pourriez avoir besoin.

Si vous avez besoin d’un accès HTTP et HTTPS pour passer à travers un proxy, lancez la commande suivante :

herd set-http-proxy guix-daemon URL

URL est l’URL du proxy, par exemple http://example.org:8118.

Si vous le souhaitez, vous pouvez continuer l’installation à distance en démarrant un serveur SSH :

herd start ssh-daemon

Assurez-vous soit de définir un mot de passe avec passwd, soit de configurer l’authentification par clef OpenSSH avant de vous connecter.

3.6.1.3 Partitionnement

À moins que vous ne l’ayez déjà fait, l’étape suivante consiste à partitionner le disque puis à formater les partitions cibles.

L’image d’installation inclus plusieurs outils de partitionnement, dont Parted (voir Overview dans GNU Parted User Manual), fdisk, et cfdisk. Lancez-en un et paramétrez votre disque avec le partitionnement qui vous convient :

cfdisk

Si votre disque utilise le format des tables de partitions GUID (GPT) et que vous souhaitez installer un GRUB pour système BIOS (c’est le cas par défaut), assurez-vous de créer qu’une partition de démarrage BIOS soit bien disponible (voir BIOS installation dans GNU GRUB manual).

Si vous souhaitez à la place utilise GRUB pour système EFI, vous devrez avoir une partition système EFI (ESP) en FAT32. Cette partition peut être montée dans /boot/efi par exemple et doit avoir le drapeau esp. P. ex. pour parted :

parted /dev/sda set 1 esp on

Remarque : Vous n’êtes pas sûr de savoir si vous devez utiliser un GRUB EFI ou BIOS ? Si le répertoire /sys/firmware/efi existe sur l’image d’installation, vous devriez probablement effectuer une installation EFI, avec grub-efi-bootloader. Sinon, vous devriez utiliser le GRUB en BIOS, grub-bootloader. Voir Configuration du chargeur d'amorçage pour plus d’information sur le chargeur d’amorçage.

Once you are done partitioning the target hard disk drive, you have to create a file system on the relevant partition(s)8. For the ESP, if you have one and assuming it is /dev/sda1, run:

mkfs.fat -F32 /dev/sda1

Concernant le système de fichier root, ext4 est le format le plus largement utilisé. D’autres systèmes de fichiers, comme Btrfs, supportent la compression, laquelle est reportée pour compléter agréablement la dédupplication que le démon réalise indépendamment du système de fichier (voir deduplication).

Préférez assigner une étiquette au système de fichier pour que vous puissiez vous y référer de manière fiable dans la déclaration file-system (voir Systèmes de fichiers). On le fait habituellement avec l’option -L de mkfs.ext4 et des commandes liées. Donc, en supposant que la partition racine soit sur /dev/sda2, on peut créer un système de fichier avec pour étiquette my-root avec :

mkfs.ext4 -L my-root /dev/sda2

Si vous voulez plutôt chiffrer la partition root, vous pouvez utiliser les utilitaires Cryptsetup et LUKS pour celà (voir man cryptsetup pour plus d’informations). En supposant que vous voulez stocker la partition root sur /dev/sda2, la séquence de commandes suivante vous mènerait à ce résultat :

cryptsetup luksFormat /dev/sda2
cryptsetup open --type luks /dev/sda2 my-partition
mkfs.ext4 -L my-root /dev/mapper/my-partition

Une fois cela effectué, montez le système de fichier cible dans /mnt avec une commande comme (de nouveau, en supposant que my-root est l’étiquette du système de fichiers racine) :

mount LABEL=my-root /mnt

Montez aussi tous les systèmes de fichiers que vous voudriez utiliser sur le système cible relativement à ce chemin. Si vous avez choisi d’avoir un /boot/efi comme point de montage EFI par exemple, montez-la sur /mnt/boot/efi maintenant pour qu’elle puisse être trouvée par guix system init ensuite.

Enfin, si vous souhaitez utiliser une ou plusieurs partitions de swap (voir swap space dans The GNU C Library Reference Manual), assurez-vous de les initialiser avec mkswap. En supposant que vous avez une partition de swap sur /dev/sda3, vous pouvez lancer :

mkswap /dev/sda3
swapon /dev/sda3

Autrement, vous pouvez utiliser un fichier de swap. Par exemple, en supposant que dans le nouveau système vous voulez utiliser le fichier /swapfile comme fichier de swap, vous lanceriez9 :

# Cela représente 10 Gio d'espace d'échange. Ajustez « count » pour changer la taille.
dd if=/dev/zero of=/mnt/swapfile bs=1MiB count=10240
# Par sécurité, laissez le fichier en lecture et en écriture uniquement pour root.
chmod 600 /mnt/swapfile
mkswap /mnt/swapfile
swapon /mnt/swapfile

Remarquez que si vous avez chiffré la partition racine et créé un fichier d’échange dans son système de fichier comme décrit ci-dessus, alors le chiffrement protégera aussi le fichier d’échange, comme n’importe quel fichier de ce système de fichiers.


Précédent: , Monter: Installation manuelle   [Table des matières][Index]

3.6.2 Effectuer l’installation

Lorsque la partition cible est prête et que les autres partitions sont montées, on est prêt à commencer l’installation. Commencez par :

herd start cow-store /mnt

Cela rend /gnu/store capable de faire de la copie sur écriture, de sorte que les paquets ajoutés pendant l’installation sont écrits sur le disque cible sur /mnt plutôt que gardés en mémoire. Cela est nécessaire parce que la première phase de la commande guix system init (voir plus bas) implique de télécharger ou de construire des éléments de /gnu/store qui est initialement un système de fichiers en mémoire.

Ensuite, vous devrez modifier un fichier et fournir la déclaration du système à installer. Pour cela, le système d’installation propose trois éditeurs de texte. Nous recommandons GNU nano (voir GNU nano Manual), qui supporte la coloration syntaxique la correspondance de parenthèses ; les autres éditeurs sont GNU Zile (un clone d’Emacs) et nvi (un clone de l’éditeur vi original de BSD). Nous recommandons vivement de stocker ce fichier sur le système de fichier racine cible, disons en tant que /mnt/etc/config.scm. Sinon, vous perdrez votre fichier de configuration une fois que vous aurez redémarré sur votre nouveau système.

Voir Utiliser le système de configuration, pour un aperçu de comment créer votre fichier de configuration. Les exemples de configuration dont on parle dans cette section sont disponibles dans /etc/configuration sur l’image d’installation. Ainsi, pour commencer avec une configuration du système qui fournit un serveur d’affichage graphique (un système de « bureau »), vous pouvez lancer ce qui suit :

# mkdir /mnt/etc
# cp /etc/configuration/desktop.scm /mnt/etc/config.scm
# nano /mnt/etc/config.scm

Vous devriez faire attention à ce que contient votre fichier de configuration, en particulier :

Une fois que vous avez fini les préparatifs sur le fichier de configuration, le nouveau système peut être initialisé (rappelez-vous que le système de fichiers racine cible est dans /mnt) :

guix system init /mnt/etc/config.scm /mnt

Cela copie tous les fichiers nécessaires et installe GRUB sur /dev/sdX à moins que vous ne passiez l’option --no-bootloader. Pour plus d’informations, voir Invoquer guix system. Cette commande peut engendrer des téléchargements ou des constructions pour les paquets manquants, ce qui peut prendre du temps.

Une fois que cette commande a terminé — et on l’espère réussi ! — vous pouvez lancer reboot et démarrer sur votre nouveau système. Le mot de passe root est d’abord vide ; les mots de passe des autres comptes doivent être initialisés avec la commande passwd en tant que root, à mois que votre configuration ne spécifie autre chose (voir mot de passe des comptes). Voir Après l'installation du système, pour la suite !


Suivant: , Précédent: , Monter: Installation du système   [Table des matières][Index]

3.7 Après l’installation du système

Bravo ! Vous avez maintenant redémarré sur votre système Guix ! À partir de maintenant, vous pouvez mettre à jour le système quand vous voudrez, avec :

guix pull
sudo guix system reconfigure /etc/config.scm

Cela crée une nouvelle génération du système avec les derniers paquets et services (voir Invoquer guix system). Nous vous recommandons de le faire régulièrement pour que votre système inclue les dernières misse à jour de sécurité (voir Mises à jour de sécurité).

Remarque : Remarquez que sudo guix exécute la commande guix de votre compte et non celle de root, parce que sudo ne change pas PATH. Pour utiliser explicitement le guix de root, tapez sudo -i guix ….

La différence est importante ici, car guix pull met à jour la commande guix et les définitions de paquets uniquement pour l’utilisateur sous lequel elle est exécutée. Cela signifie que si vous choisissez d’utiliser la commande guix system reconfigure dans le shell de connexion de root, vous devrez utiliser séparément la commande guix pull.

Maintenant, voir Pour démarrer, et rejoignez-nous sur #guix sur le réseau IRC Freenode ou sur guix-devel@gnu.org pour partager votre expérience !


Suivant: , Précédent: , Monter: Installation du système   [Table des matières][Index]

3.8 Installer Guix sur une machine virtuelle

Si vous souhaitez installer Guix System sur une machine virtuelle (VM) ou un serveur privé virtuel (VPS) plutôt que sur votre machine chérie, cette section est faite pour vous.

Pour démarrer une VM QEMU pour installer Guix System sur une image disque, suivez ces étapes :

  1. Tout d’abord récupérez et décompressez l’image d’installation du système Guix comme décrit précédemment (voir Installation depuis une clef USB ou un DVD).
  2. Créez une image disque qui contiendra le système installé. Pour créer une image qcow2, utilise la commande qemu-img :
    qemu-img create -f qcow2 guix-system.img 50G
    

    Le fichier qui en résulte sera bien plus petit que les 50 Go (habituellement moins de 1 Mo) mais il grossira au fur et à mesure que le stockage virtuel grossira.

  3. Démarrez l’image d’installation USB dans une VM :
    qemu-system-x86_64 -m 1024 -smp 1 -enable-kvm \
      -nic user,model=virtio-net-pci -boot menu=on,order=d \
      -drive file=guix-system.img \
      -drive media=cdrom,file=guix-system-install-1.2.0.système.iso
    

    -enable-kvm est facultatif, mais améliore nettement les performances, voir Lancer Guix dans une VM.

  4. Vous êtes maintenant root dans la VM, continuez en suivant la procédure d’installation. Voir Préparer l'installation, et suivez les instructions.

Une fois l’installation terminée, vous pouvez démarrer le système dans votre image guix-system.img. Voir Lancer Guix dans une VM, pour une manière de faire.


Précédent: , Monter: Installation du système   [Table des matières][Index]

3.9 Construire l’image d’installation

L’image d’installation décrite plus haut a été construite avec la commande guix system, plus précisément :

guix system image -t iso9660 gnu/system/install.scm

Regardez le fichier gnu/system/install.scm dans l’arborescence des sources et regardez aussi Invoquer guix system pour plus d’informations sur l’image d’installation.

3.10 Construire l’image d’installation pour les cartes ARM

De nombreuses cartes ARM requièrent une variante spécifique du chargeur d’amorçage U-Boot.

Si vous construisez une image disque et que le chargeur d’amorçage n’est pas disponible autrement (sur un autre périphérique d’amorçage etc), il est recommandé de construire une image qui inclus le chargeur d’amorçage, plus précisément :

guix system image --system=armhf-linux -e '((@ (gnu system install) os-with-u-boot) (@ (gnu system install) installation-os) "A20-OLinuXino-Lime2")'

A20-OLinuXino-Lime2 est le nom de la carte. Si vous spécifiez une carte invalide, une liste de cartes possibles sera affichée.


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

4 Pour démarrer

Vous êtes certainement arrivé·e à cette section parce que vous avez installé Guix sur une autre distribution (voir Installation), ou bien vous avez installé Guix System (voir Installation du système). Il est temps pour vous de commencer à utiliser Guix et cette section est là pour vous aider à le faire et vous donner une idée de ce que c’est.

Guix est, entre autres, un programme d’installation de logiciels, donc la première chose que vous voudrez probablement faire est de chercher un logiciel. Disons que vous cherchez un éditeur de texte, vous pouvez lancer :

guix search text editor

Cette commande vous montre un certain nombre de paquets correspondants, en indiquant à chaque fois le nom du paquet, sa version, une description et des informations supplémentaires. Une fois que vous avez trouvé celui que vous voulez utiliser, disons Emacs (ah ha !), vous pouvez l’installer (lancez cette commande en tant qu’ utilisateur·rice, pas besoin des privilèges d’administration !) :

guix install emacs

Vous avez installé votre premier paquet, félicitations ! Vous avez probablement remarqué que Guix a téléchargé des binaires pré-compilés ; ou bien, si vous vous êtes dit : non, pas de binaires pré-compilés, alors Guix est probablement encore en train de construire un logiciel (voir Substituts, pour plus d’informations).

À moins que vous utilisiez Guix System, la commande guix install doit avoir affiché cet indice :

conseil : pensez à définir les variables d'environnement nécessaires en exécutant : 
     GUIX_PROFILE="$HOME/.guix-profile"
     . "$GUIX_PROFILE/etc/profile"
Vous pouvez également consulter `guix package --search-paths -p "$HOME/.guix-profile"'.

En effet, vous devez maintenant indiquer à votre shell où se trouvent emacs et les autres programmes installés avec Guix. En collant les deux lignes ci-dessus, c’est exactement ce que vous ferez : vous ajouterez $HOME/.guix-profile/bin — qui est l’endroit où se trouve le paquet installé — à la variable d’environnement PATH. Vous pouvez coller ces deux lignes dans votre shell pour qu’elles prennent effet immédiatement, mais surtout vous devez les ajouter à ~/.bash_profile (ou un fichier équivalent si vous n’utilisez pas Bash) afin que les variables d’environnement soient définies la prochaine fois que vous lancerez un shell. Vous n’avez besoin de le faire qu’une seule fois et les autres variables d’environnement des chemins de recherche seront traitées de la même manière — par exemple, si vous installez les bibliothèques python et Python, PYTHONPATH sera définie.

Vous pouvez continuer à installer des paquets à votre guise. Pour lister les paquets installés, lancez :

guix package --list-installed

Pour supprimer un paquet, sans surprise, lancez guix remove. Une caractéristique distinctive est la possibilité de faire revenir en arrière toute opération que vous avez effectuée — installation, suppression, mise à niveau — en tapant simplement :

guix package --roll-back

C’est parce que chaque opération est en fait une transaction qui crée une nouvelle génération. Les générations et leurs différences entre elles peuvent être affichées en lançant :

guix package --list-generations

Vous connaissez maintenant les bases de la gestion des paquets !

Aller plus loin : Voir Gestion de paquets, pour en savoir plus sur la gestion des paquets. Vous pouvez aimer la gestion declarative des paquets avec guix package --manifest, la gestion de profils séparés avec --profil, la suppression des anciennes générations, le ramasse-miettes et d’autres fonctionnalités astucieuses qui vous seront utiles à mesure que vous vous familiariserez avec Guix. Si vous développez du code, voir Développement pour des outils supplémentaires. Et si vous êtes curieux·euse, voir Fonctionnalités, pour jeter un coup d’œil sous le capot.

Une fois que vous avez installé un ensemble de paquets, vous voudrez périodiquement faire une mise à jour à la dernière version flambant neuve. Pour cela, vous devez d’abord récupérer la dernière révision de Guix et de sa collection de paquets :

guix pull

Le résultat final est une nouvelle commande guix, sous ~/.config/guix/current/bin. A moins que vous ne soyez sous Guix System, la première fois que vous lancez guix pull, assurez-vous de suivre le conseil que la commande affiche et, comme nous l’avons vu ci-dessus, collez ces deux lignes dans votre terminal et dans .bash_profile:

GUIX_PROFILE="$HOME/.config/guix/current"
. "$GUIX_PROFILE/etc/profile"

Vous devez aussi informer votre shell de pointer sur ce nouveau guix:

hash guix

A ce stade, vous pilotez un Guix tout neuf. Vous pouvez donc aller de l’avant et mettre effectivement à jour tous les paquets que vous avez installés précédemment :

guix upgrade

En exécutant cette commande, vous verrez que des binaires sont téléchargés (ou peut-être que certains paquets sont construits), et vous finirez par obtenir les paquets mis à jour. Si l’un de ces paquets n’est pas à votre goût, n’oubliez pas que vous pouvez toujours revenir en arrière !

Vous pouvez afficher la révision exacte de Guix actuellement en cours d’exécution en lançant :

guix describe

L’information affichée est tout ce qu’il faut pour reproduire exactement le même Guix, que ce soit à un moment différent ou sur une machine différente.

Aller plus loin : Voir Invoquer guix pull, pour plus d’informations. Voir Canaux, sur la façon de spécifier des canaux supplémentaires pour extraire des paquets, sur la façon de répliquer Guix, et plus encore. Vous pouvez également trouver time-machine pratique (voir Invoquer guix time-machine).

Si vous avez installé Guix System, une des premières choses que vous voudrez faire est de le mettre à jour. Une fois que vous avez lancé guix pull pour obtenir le dernier Guix, vous pouvez mettre à jour le système comme ceci :

sudo guix system reconfigure /etc/config.scm

Ceci terminé, le système exécute les dernières versions de ses logiciels. Lorsque vous redémarrez, vous remarquerez un sous-menu dans le chargeur d’amorçage qui indique « Old system generations » : c’est ce qui vous permet de démarrer une ancienne génération de votre système, si la dernière génération est « cassée » ou insatisfaisante. Tout comme pour les paquets, vous pouvez toujours revenir à une génération précédente de l’ensemble du système :

sudo guix system roll-back

Il y a beaucoup de choses que vous voudrez probablement modifier sur votre système : ajouter de nouveaux comptes utilisateur·rice·s, ajouter de nouveaux services système, modifier la configuration de ces services, etc. La configuration du système est entièrement décrite dans le fichier /etc/config.scm. Voir Utiliser le système de configuration, pour apprendre à le modifier.

Maintenant, vous en savez assez pour commencer !

Ressources : Le reste de ce manuel constitue une référence pour tout ce qui concerne Guix. Voici quelques ressources supplémentaires que vous pourriez trouver utiles :

Nous espérons que vous apprécierez Guix autant que la communauté a de plaisir à le construire !


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

5 Gestion de paquets

Le but de GNU Guix est de permettre à ses utilisatrices et utilisateurs d’installer, mettre à jour et supprimer facilement des paquets logiciels sans devoir connaître leur procédure de construction ou leurs dépendances. Guix va aussi plus loin que ces fonctionnalités évidentes.

Ce chapitre décrit les principales fonctionnalités de Guix, ainsi que des outils de gestion des paquets qu’il fournit. En plus de l’interface en ligne de commande décrite en dessous de (voir guix package), vous pouvez aussi utiliser l’interface Emacs-Guix (voir Le manuel de référence de emacs-guix), après avoir installé le paquet emacs-guix (lancez la commande M-x guix-help pour le démarrer) :

guix install emacs-guix

Suivant: , Monter: Gestion de paquets   [Table des matières][Index]

5.1 Fonctionnalités

Ici, nous supposons que vous avez déjà fait vos premiers pas avec Guix voir Pour démarrer) et que vous voulez avoir un aperçu de ce qui se passe sous le capot.

Lorsque vous utilisez Guix, chaque paquet arrive dans dépôt des paquets, dans son propre répertoire — quelque chose comme /gnu/store/xxx-paquet-1.2, où xxx est une chaîne en base32.

Plutôt que de se rapporter à ces répertoires, les utilisateur·rice·s ont leur propre profil qui pointe vers les paquets qu’ils ou elles veulent vraiment utiliser. Ces profils sont stockés dans le répertoire personnel de chacun·e dans $HOME/.guix-profile.

Par exemple, alice installe GCC 4.7.2. Il en résulte que /home/alice/.guix-profile/bin/gcc pointe vers /gnu/store/…-gcc-4.7.2/bin/gcc. Maintenant, sur la même machine, bob a déjà installé GCC 4.8.0. Le profil de bob continue simplement de pointer vers /gnu/store/…-gcc-4.8.0/bin/gcc — c.-à-d. les deux versions de GCC coexistent surs le même système sans aucune interférence.

La commande guix package est l’outil central pour gérer les paquets (voir Invoquer guix package). Il opère sur les profils de chaque utilisateur·rice et peut être utilisé avec les privilèges normaux.

La commande fournit les opérations évidentes d’installation, de suppression et de mise à jour. Chaque invocation est en fait une transaction : soit l’opération demandée réussit, soit rien ne se passe. Ainsi, si le processus guix package est terminé pendant la transaction ou si une panne de courant arrive pendant la transaction, le profil reste dans son état précédent et reste utilisable.

En plus, il est possible d’annuler toute transaction sur les paquets. Donc si par exemple un mise à jour installe une nouvelle version d’un paquet qui révèle un bogue sérieux, vous pouvez revenir en arrière à l’instance précédente de votre profil que vous saviez bien fonctionner. De même, la configuration globale du système dans Guix est sujette aux mises à jour transactionnelles et aux annulations (voir Utiliser le système de configuration).

Tout paquet du dépôt des paquets peut être glané. Guix peut déterminer quels paquets sont toujours référencés par les profils des utilisateur·rice·s et supprimer ceux qui ne sont de tout évidence plus référencés (voir Invoquer guix gc). Les utilisateur·rice·s peuvent toujours explicitement supprimer les anciennes générations de leur profil pour que les paquets auxquels elles faisaient référence puissent être glanés.

Guix prend une approche purement fonctionnelle de la gestion de paquets, telle que décrite dans l’introduction (voir Introduction). Chaque nom de répertoire de paquet dans /gnu/store contient un hash de toutes les entrées qui ont été utilisées pendant la construction de ce paquet — le compilateur, les bibliothèques, les scripts de construction, etc. Cette correspondance directe permet aux utilisateur·rice·s de s’assurer que l’installation d’un paquet donné correspond à l’état actuel de leur distribution. Elle aide aussi à maximiser la reproductibilité : grâce aux environnements de construction utilisés, une construction donnée a de forte chances de donner des fichiers identiques bit-à-bit lorsqu’elle est effectuée sur des machines différentes (voir container).

Ce fondement permet à Guix de supporter le déploiement transparent de binaire ou source. Lorsqu’une binaire pré-construit pour une entrée de /gnu/store est disponible depuis une source externe (un substitut), Guix le télécharge simplement et le décompresse ; sinon, il construit le paquet depuis les sources localement (voir Substituts). Comme les résultats des constructions sont généralement reproductibles au bit près, si vous n’avez pas besoin de faire confiance aux serveurs qui fournissent les substituts : vous pouvez forcer une construction locale et défier les fournisseurs (voir Invoquer guix challenge).

Le contrôle de l’environnement de construction est aussi une fonctionnalité utile pour les développeurs. La commande guix environment permet aux développeurs d’un paquet de mettre en place rapidement le bon environnement de développement pour leur paquet, sans avoir à installer manuellement les dépendances du paquet dans leur profil (voir Invoquer guix environment).

La totalité de Guix et des définitions de paquets sont placés sous contrôle de version, et guix pull vous permet de « voyager dans le temps » de l’historique de Guix lui-même (voir Invoquer guix pull). Cela est rend possible la réplication d’une instance Guix sur une machine différente ou plus tard, ce qui vous permet de répliquer des environnements logiciels complets, tout en garantissant un suivi de provenance précis des logiciels.


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.2 Invoquer guix package

La commande guix package est l’outil qui permet d’installer, mettre à jour et supprimer les paquets ainsi que de revenir à une configuration précédente. Elle n’opère que dans le profil de l’utilisateur·rice et fonctionne avec les privilèges normaux (voir Fonctionnalités). Sa syntaxe est :

guix package options

options spécifie d’abord les opérations à effectuer pendant la transaction. À la fin, une nouvelle génération du profil est créée mais les générations précédentes du profil restent disponibles si l’utilisateur·rice souhaite y revenir.

Par exemple, pour supprimer lua et installer guile et guile-cairo en une seule transaction :

guix package -r lua -i guile guile-cairo

Parce que c’est pratique, nous fournissons aussi les alias suivants :

Ces alias sont moins expressifs que guix package et fournissent moins d’options, donc dans certains cas vous devrez probablement utiliser guix package directement.

guix package supporte aussi une approche déclarative où on spécifie l’ensemble exact des paquets qui doivent être disponibles que l’on passe via l’option --manifest (voir --manifest).

Pour chaque utilisateur·rice, un lien symbolique vers son profil par défaut est automatiquement créé dans $HOME/.guix-profile. Ce lien symbolique pointe toujours vers la génération actuelle du profil par défaut du compte. Ainsi, on peut ajouter $HOME/.guix-profile/bin à sa variable d’environnement PATH etc. Si vous n’utilisez pas la distribution système Guix, vous devriez ajouter les lignes suivantes à votre ~/.bash_profile (voir Bash Startup Files dans The GNU Bash Reference Manual) pour que les shells créés ensuite aient tous les bonnes définitions des variables d’environnement :

GUIX_PROFILE="$HOME/.guix-profile" ; \
source "$GUIX_PROFILE/etc/profile"

Dans un environnement multi-utilisateur·rice, les profils des utilisateur·rice·s sont stockés dans un emplacement enregistré comme garbage-collector root, vers lequel $HOME/.guix-profile pointe (voir Invoquer guix gc). Ce répertoire est normalement localstatedir/guix/profiles/per-user/user, où localstatedir est la valeur passée à configure comme --localstatedir, et user est le nom d’utilisateur·rice. Le répertoire per-user est créé au démarrage de guix-daemon, et le sous-répertoire user est créé par guix package.

Les options peuvent être les suivante :

--install=paquet
-i paquet

Installer les paquets spécifiés.

Chaque paquet peut spécifier soit un simple nom de paquet, tel que guile, soit un nom de paquet suivi d’un at-sign et d’un numéro de version, tel que guile@1.8.8 ou simplement guile@1.8. (dans ce dernier cas, la version la plus récente préfixée par 1.8 est sélectionnée).

Si aucun numéro de version n’est spécifié, la version la plus récente disponible est choisie. En plus, paquet peut contenir un deux-points, suivi du nom d’une des sorties du paquet, comme dans gcc:doc ou binutils@2.22:lib (voir Des paquets avec plusieurs résultats). Des paquets avec un nom correspondant et (éventuellement une version) sont recherchés dans les modules de la distribution GNU (voir Modules de paquets).

Parfois les paquets ont des entrées propagées : ce sont des dépendances qui sont installées automatiquement avec le paquet demandé (voir propagated-inputs in package objects pour plus d’informations sur les entrées propagées dans les définitions des paquets).

Un exemple est la bibliothèque MPC de GNU : ses fichiers d’en-tête C se réfèrent à ceux de la bibliothèque MPFR de GNU, qui se réfèrent en retour à ceux de la bibliothèque GMP. Ainsi, lorsqu’on installe MPC, les bibliothèques MPFR et GMP sont aussi installées dans le profil ; supprimer MPC supprimera aussi MPFR et GMP — à moins qu’ils n’aient été aussi installés explicitement par l’utilisateur·rice.

En outre, les paquets s’appuient parfois sur la définition de variables d’environnement pour leurs chemins de recherche (voir l’explication de l’--chemins de recherche ci-dessous). Toute définition de variable d’environnement manquante ou éventuellement incorrecte est reportée ici.

--install-from-expression=exp
-e exp

Installer le paquet évalué par exp

exp doit être une expression Scheme qui s’évalue en un objet <package>. Cette option est notamment utile pour distinguer les variantes d’un paquet avec le même nom, avec des expressions comme (@ (gnu packages base) guile-final).

Remarquez que cette option installe la première sortie du paquet, ce qui peut être insuffisant lorsque vous avez besoin d’une sortie spécifique d’un paquet à plusieurs sorties.

--install-from-file=fichier
-f fichier

Installer le paquet évalué par le code dans le fichier.

Par exemple, fichier peut contenir une définition comme celle-ci (voir Définition des paquets) :

(use-modules (guix)
             (guix build-system gnu)
             (guix licenses))

(package
  (name "hello")
  (version "2.10")
  (source (origin
            (method url-fetch)
            (uri (string-append "mirror://gnu/hello/hello-" version
                                ".tar.gz"))
            (sha256
             (base32
              "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
  (build-system gnu-build-system)
  (synopsis "Hello, GNU world: An example GNU package")
  (description "Guess what GNU Hello prints!")
  (home-page "http://www.gnu.org/software/hello/")
  (license gpl3+))

Lorsqu’on développe, on peut trouver utile d’inclure un tel fichier guix.scm à la racine de l’arborescence des sources de son projet qui pourrait être utilisé pour tester des versions de développement et créer des environnements de développement reproductibles (voir Invoquer guix environment).

Le fichier peut aussi contenir une représentation JSON d’une ou de plusieurs définitions de paquets. L’exécution de guix package -f sur hello.json avec le contenu suivant entraînerait l’installation du paquet greeter après la construction de myhello :

[
  {
    "name": "myhello",
    "version": "2.10",
    "source": "mirror://gnu/hello/hello-2.10.tar.gz",
    "build-system": "gnu",
    "arguments": {
      "tests?": false
    }
    "home-page": "https://www.gnu.org/software/hello/",
    "synopsis": "Hello, GNU world: An example GNU package",
    "description": "GNU Hello prints a greeting.",
    "license": "GPL-3.0+",
    "native-inputs": ["gettext"]
  },
  {
    "name": "greeter",
    "version": "1.0",
    "source": "https://example.com/greeter-1.0.tar.gz",
    "build-system": "gnu",
    "arguments": {
      "test-target": "foo",
      "parallel-build?": false,
    },
    "home-page": "https://example.com/",
    "synopsis": "Greeter using GNU Hello",
    "description": "This is a wrapper around GNU Hello.",
    "license": "GPL-3.0+",
    "inputs": ["myhello", "hello"]
  }
]
--remove=paquet
-r paquet

Supprimer les paquets spécifiés.

Comme pour --install, chaque paquet peut spécifier un numéro de version ou un nom de sortie en plus du nom du paquet. Par exemple, ‘-r glibc:debug’ supprimerait la sortie debug de glibc.

--upgrade[=regexp …]
-u [regexp …]

Mettre à jour tous les paquets installés. Si un ou plusieurs regexp sont spécifiés, la mise à jour n’installera que les paquets dont le nom correspond à regexp. Voir aussi l’option --do-not-upgrade ci-dessous.

Remarquez que cela met à jour vers la dernière version des paquets trouvée dans la distribution actuellement installée. Pour mettre à jour votre distribution, vous devriez lancer régulièrement guix pull (voir Invoquer guix pull).

Quand une mise à jour est en cours d’exécution, les transformations de paquets initialement appliquées lors de la création du profil sont automatiquement réappliquées (voir Options de transformation de paquets). Par exemple, supposons que vous ayez d’abord installé Emacs depuis l’extrémité de sa branche de développement avec :

guix install emacs-next --with-branch=emacs-next=master

La prochaine fois que vous lancerez guix upgrade, Guix va à nouveau extraire l’extrémité de la branche de développement Emacs et construira emacs-next à partir de ce checkout.

Notez que les options de transformation comme --with-branch et --with-source dépendent de l’état exterieur ; c’est à vous de vous assurer qu’elles fonctionnent comme souhaité. Vous pouvez également écarter une transformation qui s’applique à un paquet en lançant :

$ guix install paquet
--do-not-upgrade[=regexp …]

Lors d’une utilisation conjointe avec l’option --upgrade, ne pas mettre à jour les paquets dont le nom correspond à regexp. Par exemple, pour mettre à jour tous les paquets du profil actuel à l’exception de ceux qui contiennent la chaîne « emacs » :

$ guix package --upgrade . --do-not-upgrade emacs
--manifest=fichier
-m fichier

Créer une nouvelle génération du profil depuis l’objet manifeste renvoyé par le code Scheme dans fichier. Cette option peut être répétée plusieurs fois, auquel cas les manifestes sont concaténés.

Cela vous permet de déclarer le contenu du profil plutôt que de le construire avec une série de --install et de commandes similaires. L’avantage étant que le fichier peut être placé sous contrôle de version, copié vers d’autres machines pour reproduire le même profil, etc.

fichier doit renvoyer un objet manifest qui est en gros une liste de paquets :

(use-package-modules guile emacs)

(packages->manifest
 (list emacs
       guile-2.0
       ;; Utiliser une sortie spécifique d'un paquet.
       (list guile-2.0 "debug")))

Dans cet exemple on doit savoir quels modules définissent les variables emacs et guile-2.0 pour fournir la bonne ligne use-package-modules ce qui peut être embêtant. On peut à la place fournir des spécifications de paquets normales et laisser specifications->manifest rechercher les objets de paquets correspondants, comme ceci :

(specifications->manifest
 '("emacs" "guile@2.2" "guile@2.2:debug"))

Voir --export-manifest, to learn how to obtain a manifest file from an existing profile.

--roll-back

Revenir à la génération précédente du profil c.-à-d. défaire la dernière transaction.

Lorsqu’elle est combinée avec des options comme --install, Le retour en arrière se produit avant toute autre action.

Lorsque vous revenez de la première génération qui contient des fichiers, le profil pointera vers la zéroième génération qui ne contient aucun fichier en dehors de ses propres métadonnées.

Après être revenu en arrière, l’installation, la suppression et la mise à jour de paquets réécrit les futures générations précédentes. Ainsi, l’historique des générations dans un profil est toujours linéaire.

--switch-generation=motif
-S motif

Basculer vers une génération particulière définie par le motif.

Le motif peut être soit un numéro de génération soit un nombre précédé de « + » ou « - ». Ce dernier signifie : se déplacer en avant ou en arrière d’un nombre donné de générations. Par exemple, si vous voulez retourner à la dernière génération après --roll-back, utilisez --switch-generation=+1.

La différence entre --roll-back et --switch-generation=-1 est que --switch-generation ne vous amènera pas à la génération initiale, donc si la génération demandée n’existe pas la génération actuelle ne changera pas.

--search-paths[=genre]

Rapporter les définitions des variables d’environnement dans la syntaxe Bash qui peuvent être requises pour utiliser l’ensemble des paquets installés. Ces variables d’environnement sont utilisées pour spécifier les chemins de recherche de fichiers utilisés par les paquets installés.

Par exemple, GCC a besoin des variables d’environnement CPATH et LIBRARY_PATH pour trouver les en-têtes et les bibliothèques dans le profil de l’utilisateur·rice (voir Environment Variables dans Using the GNU Compiler Collection (GCC)). Si GCC et, disons, la bibliothèque C sont installés dans le profil, alors --search-paths suggérera d’initialiser ces variables à profil/include et profil/lib, respectivement.

Le cas d’utilisation typique est de définir ces variables d’environnement dans le shell :

$ eval `guix package --search-paths`

genre peut être l’une des valeurs exact, prefix ou suffix, ce qui signifie que les définitions des variables d’environnement renvoyées seront soit les paramètres exacts, soit placés avant ou après la valeur actuelle de ces paramètres. Lorsqu’il est omis, genre a pour valeur par défaut exact.

Cette option peut aussi être utilisé pour calculer les chemins de recherche combinés de plusieurs profils. Regardez cet exemple :

$ guix package -p foo -i guile
$ guix package -p bar -i guile-json
$ guix package -p foo -p bar --search-paths

La dernière commande ci-dessus montre la variable GUILE_LOAD_PATH bien que, pris individuellement, ni foo ni bar n’auraient donné cette recommandation.

--profile=profil
-p profil

Utiliser le profil à la place du profil par défaut du compte.

profil doit être le nom d’un fichier qui sera créé une fois terminé. Concrètement, profil sera un simple lien symbolique (« symlink ») pointant vers le profil réel où les paquets sont installés :

$ guix install hello -p ~/code/my-profile
…
$ ~/code/my-profile/bin/hello
Hello, world!

Tout ce qu’il faut pour se débarrasser du profil est de supprimer ce lien symbolique et ses frères et sœurs qui pointent vers des générations spécifiques :

$ rm ~/code/my-profile ~/code/my-profile-*-link
--list-profiles

Liste tous les profils utilisateur·rice :

$ guix package --list-profiles
/home/charlie/.guix-profile
/home/charlie/code/my-profile
/home/charlie/code/devel-profile
/home/charlie/tmp/test

En cours d’exécution sous root, liste tous les profils de tou·te·s les utilisateur·rice·s.

--allow-collisions

Permettre des collisions de paquets dans le nouveau profil. À utiliser à vos risques et périls !

Par défaut, guix package rapporte les collisions dans le profil comme des erreurs. Les collisions ont lieu quand deux version ou variantes d’un paquet donné se retrouvent dans le profil.

--bootstrap

Utiliser le programme d’amorçage Guile pour compiler le profil. Cette option n’est utile qu’aux personnes qui développent la distribution.

En plus de ces actions, guix package supporte les options suivantes pour demander l’état actuel d’un profil ou la disponibilité des paquets :

--search=regexp
-s regexp

Lister les paquets disponibles dont le nom, le synopsis ou la description correspondent à la regexp (en étant insensible à la casse), triés par pertinence. Afficher toutes les métadonnées des paquets correspondants au format recutils (voir GNU recutils databases dans GNU recutils manual).

Cela permet à des champs spécifiques d’être extraits avec la commande recsel, par exemple :

$ guix package -s malloc | recsel -p name,version,relevance
name: jemalloc
version: 4.5.0
relevance: 6

name: glibc
version: 2.25
relevance: 1

name: libgc
version: 7.6.0
relevance: 1

De manière similaire, pour montrer le nom de tous les paquets disponibles sous license GNU LGPL version 3 :

$ guix package -s "" | recsel -p name -e 'license ~ "LGPL 3"'
name: elfutils

name: gmp
…

Il est aussi possible de raffiner les résultats de la recherche en donnant plusieurs options -s à guix package, ou plusieurs arguments à guix search. Par exemple, la commande suivante renvoie la liste des jeux de plateau (cette fois-ci avec l’alias guix search) :

$ guix search '\<board\>' game | recsel -p name
name: gnubg
…

Si on avait oublié -s game, on aurait aussi eu les paquets logiciels qui s’occupent de circuits imprimés (en anglais : circuit board) ; supprimer les chevrons autour de board aurait aussi ajouté les paquets qui parlent de clavier (en anglais : keyboard).

Et maintenant un exemple plus élaboré. La commande suivante recherche les bibliothèques cryptographiques, retire les bibliothèques Haskell, Perl, Python et Ruby et affiche le nom et le synopsis des paquets correspondants :

$ guix search crypto library | \
    recsel -e '! (name ~ "^(ghc|perl|python|ruby)")' -p name,synopsis

Voir Selection Expressions dans GNU recutils manual pour plus d’information sur les expressions de sélection pour recsel -e.

--show=paquet

Afficher les détails du paquet dans la liste des paquets disponibles, au format recutils (voir GNU recutils databases dans GNU recutils manual).

$ guix package --show=python | recsel -p name,version
name: python
version: 2.7.6

name: python
version: 3.3.5

Vous pouvez aussi spécifier le nom complet d’un paquet pour n’avoir que les détails concernant une version spécifique (cette fois-ci avec l’alias guix show) :

$ guix show python@3.4 | recsel -p name,version
name: python
version: 3.4.3
--list-installed[=regexp]
-I [regexp]

Liste les paquets actuellement installés dans le profil spécifié, avec les paquets les plus récemment installés en dernier. Lorsque regexp est spécifié, liste uniquement les paquets installés dont le nom correspond à regexp.

Pour chaque paquet installé, affiche les éléments suivants, séparés par des tabulations : le nom du paquet, sa version, la partie du paquet qui est installé (par exemple, out pour la sortie par défaut, include pour ses en-têtes, etc) et le chemin du paquet dans le dépôt.

--list-available[=regexp]
-A [regexp]

Lister les paquets actuellement disponibles dans la distribution pour ce système (voir Distribution GNU). Lorsque regexp est spécifié, lister uniquement les paquets dont le nom correspond à regexp.

Pour chaque paquet, affiche les éléments suivants séparés par des tabulations : son nom, sa version, les parties du paquet (voir Des paquets avec plusieurs résultats), et l’emplacement de sa définition.

--list-generations[=motif]
-l [motif]

Renvoyer la liste des générations avec leur date de création ; pour chaque génération, montre les paquets installés avec les paquets installés les plus récemment en dernier. Remarquez que la zéroième génération n’est jamais montrée.

Pour chaque paquet installé, afficher les éléments suivants, séparés par des tabulations : le nom du paquet, sa version, la partie du paquet qui a été installée (voir Des paquets avec plusieurs résultats), et l’emplacement du paquet dans le dépôt.

Lorsque motif est utilisé, la commande ne renvoie que les générations correspondantes. Les motifs valides sont :

--delete-generations[=motif]
-d [motif]

Lorsque motif est omis, supprimer toutes les générations en dehors de l’actuelle.

Cette commande accepte les même motifs que --list-generations. Lorsque motif est spécifié, supprime les générations correspondantes. Lorsque motif spécifie une durée, les générations plus anciennes que la durée spécifiée correspondent. Par exemple --delete-generations=1m supprime les générations vieilles de plus d’un mois.

Si la génération actuelle correspond, elle n’est pas supprimée. La zéroième génération n’est elle non plus jamais supprimée.

Remarquez que supprimer des générations empêche de revenir en arrière vers elles. Ainsi, cette commande doit être utilisée avec précaution.

--export-manifest

Write to standard output a manifest suitable for --manifest corresponding to the chosen profile(s).

This option is meant to help you migrate from the “imperative” operating mode—running guix install, guix upgrade, etc.—to the declarative mode that --manifest offers.

Be aware that the resulting manifest approximates what your profile actually contains; for instance, depending on how your profile was created, it can refer to packages or package versions that are not exactly what you specified.

Keep in mind that a manifest is purely symbolic: it only contains package names and possibly versions, and their meaning varies over time. If you wish to “pin” channels to the revisions that were used to build the profile(s), see --export-channels below.

--export-channels

Write to standard output the list of channels used by the chosen profile(s), in a format suitable for guix pull --channels or guix time-machine --channels (voir Canaux).

Together with --export-manifest, this option provides information allowing you to replicate the current profile (voir Répliquer Guix).

However, note that the output of this command approximates what was actually used to build this profile. In particular, a single profile might have been built from several different revisions of the same channel. In that case, --export-manifest chooses the last one and writes the list of other revisions in a comment. If you really need to pick packages from different channel revisions, you can use inferiors in your manifest to do so (voir Inférieurs).

Together with --export-manifest, this is a good starting point if you are willing to migrate from the “imperative” model to the fully declarative model consisting of a manifest file along with a channels file pinning the exact channel revision(s) you want.

Finally, since guix package may actually start build processes, it supports all the common build options (voir Options de construction communes). It also supports package transformation options, such as --with-source, and preserves them across upgrades (voir Options de transformation de paquets).


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.3 Substituts

Guix gère le déploiement depuis des binaires ou des sources de manière transparente ce qui signifie qu’il peut aussi bien construire localement que télécharger des éléments pré-construits depuis un serveur ou les deux. Nous appelons ces éléments pré-construits des substituts — ils se substituent aux résultats des constructions locales. Dans la plupart des cas, télécharger un substitut est bien plus rapide que de construire les choses localement.

Les substituts peuvent être tout ce qui résulte d’une construction de dérivation (voir Dérivations). Bien sûr dans le cas général, il s’agit de paquets binaires pré-construits, mais les archives des sources par exemple résultent aussi de la construction d’une dérivation qui peut aussi être disponible en tant que substitut.


Suivant: , Monter: Substituts   [Table des matières][Index]

5.3.1 Serveur de substituts officiel

Le serveur ci.guix.gnu.org est une interface à la ferme de construction officielle qui construit des paquets pour Guix continuellement pour certaines architectures et les rend disponibles en tant que substituts. C’est la source par défaut des substituts ; elle peut être modifiée en passant l’option --substitute-urls soit à guix-daemon (voir guix-daemon --substitute-urls) soit aux outils clients comme guix package (voir client --substitute-urls option).

Les URL des substituts peuvent être soit en HTTP soit en HTTPS. Le HTTPS est recommandé parce que les communications sont chiffrées ; à l’inverse HTTP rend les communications visibles pour un espion qui peut utiliser les informations accumulées sur vous pour déterminer par exemple si votre système a des vulnérabilités de sécurités non corrigées.

Les substituts de la ferme de construction officielle sont activés par défaut dans la distribution système Guix (voir Distribution GNU). Cependant, ils sont désactivés par défaut lorsque vous utilisez Guix sur une distribution externe, à moins que vous ne les ayez explicitement activés via l’une des étapes d’installation recommandées (voir Installation). Les paragraphes suivants décrivent comment activer ou désactiver les substituts pour la ferme de construction officielle ; la même procédure peut être utilisée pour activer les substituts de n’importe quel autre serveur de substituts.


Suivant: , Précédent: , Monter: Substituts   [Table des matières][Index]

5.3.2 Autoriser un serveur de substituts

Pour permettre à Guix de télécharger les substituts depuis ci.guix.gnu.org ou un miroir, vous devez ajouter sa clef publique à la liste de contrôle d’accès (ACL) des imports d’archives, avec la commande guix archive (voir Invoquer guix archive). Cela implique que vous faîtes confiance à ci.guix.gnu.org pour ne pas être compromis et vous servir des substituts authentiques.

Remarque : Si vous utilisez le système Guix, vous pouvez sauter cette section : le système Guix autorise les substituts de ci.guix.gnu.org par défaut.

La clef publique pour ci.guix.gnu.org est installée avec Guix, dans préfixe/share/guix/ci.guix.gnu.org.pub, où préfixe est le préfixe d’installation de Guix. Si vous avez installé Guix depuis les sources, assurez-vous d’avoir vérifié la signature GPG de guix-1.2.0.tar.gz qui contient ce fichier de clef publique. Ensuite vous pouvez lancer quelque chose comme ceci :

# guix archive --authorize < prefix/share/guix/ci.guix.gnu.org.pub

Une fois que cela est en place, la sortie d’une commande comme guix build devrait changer de quelque chose comme :

$ guix build emacs --dry-run
Les dérivations suivantes seraient construites :
   /gnu/store/yr7bnx8xwcayd6j95r2clmkdl1qh688w-emacs-24.3.drv
   /gnu/store/x8qsh1hlhgjx6cwsjyvybnfv2i37z23w-dbus-1.6.4.tar.gz.drv
   /gnu/store/1ixwp12fl950d15h2cj11c73733jay0z-alsa-lib-1.0.27.1.tar.bz2.drv
   /gnu/store/nlma1pw0p603fpfiqy7kn4zm105r5dmw-util-linux-2.21.drv
…

à quelque chose comme :

$ guix build emacs --dry-run
112.3 Mo seraient téléchargés :
   /gnu/store/pk3n22lbq6ydamyymqkkz7i69wiwjiwi-emacs-24.3
   /gnu/store/2ygn4ncnhrpr61rssa6z0d9x22si0va3-libjpeg-8d
   /gnu/store/71yz6lgx4dazma9dwn2mcjxaah9w77jq-cairo-1.12.16
   /gnu/store/7zdhgp0n1518lvfn8mb96sxqfmvqrl7v-libxrender-0.9.7
…

Le texte a changé de « Les dérivations suivantes seront construites » à « 112,3 Mio seront téléchargés ». Cela indique que les substituts de ci.guix.gnu.org sont utilisables et seront téléchargés, si possible, pour les futures constructions.

Le mécanisme de substitution peut être désactivé globalement en lançant guix-daemon avec --no-substitutes (voir Invoquer guix-daemon). Il peut aussi être désactivé temporairement en passant l’option --no-substitutes à guix package, guix build et aux autres outils en ligne de commande.


Suivant: , Précédent: , Monter: Substituts   [Table des matières][Index]

5.3.3 Récupérer des substituts d’autres serveurs

Guix peut chercher et récupérer des substituts à partir de plusieurs serveurs. C’est utile si vous utilisez des paquets de canaux supplémentaires pour lesquels le serveur officiel n’a pas de substituts mais que d’autres serveurs les fournissent. Une autre situation où cela est utile est si vous souhaitez télécharger depuis les serveurs de substituts de votre organisation, en utilisant le serveur officiel en dernier recours, ou en ne l’utilisant pas du tout.

Vous pouvez donner à Guix une liste d’URL de serveurs de substituts et il les vérifiera dans l’ordre indiqué. Vous devez aussi explicitement autoriser les clés publiques des serveurs de substituts pour dire à Guix d’accepter les substituts qu’ils signent.

Sur le système Guix, cela se fait en modifiant la configuration du service guix. Comme le service guix fait partie des services par défaut, %base-services et %desktop-services, vous pouvez utiliser modify-services pour changer sa configuration et ajouter les URL et les clés des serveurs de substituts que vous voulez (voir modify-services).

Par exemple, supposons que vous vouliez récupérer les substituts de guix.example.org et autoriser la clé de signature de ce serveur, en plus du serveur ci.guix.gnu.org par défaut. La configuration du système d’exploitation qui en résulte ressemblera à :

(operating-system
  ;; …
  (services
    ;; Supposons qu'on commence à partir de '%desktop-services'.  Remplaçons-le
    ;; par la liste des services qu'on utilise vraiment.
    (modify-services %desktop-services
      (guix-service-type config =>
                        (guix-configuration
                          (inherit config)
                          (substitute-urls
                            (append (list "https://guix.example.org")
                                    %default-substitute-urls))
                          (authorized-keys
                            (append (list (local-file "./key.pub"))
                                    %default-authorized-guix-keys)))))))

Cela suppose que le fichier key.pub contient la clé de signature de guix.example.org. Avec ce changement dans le fichier de configuration de votre système d’exploitation (disons /etc/config.scm), vous pouvez reconfigurer et redémarrer le service guix-daemon ou redémarrer pour que les changements prennent effet :

$ sudo guix system reconfigure /etc/config.scm
$ sudo herd restart guix-daemon

Si vous utilisez Guix sur une « distro externe », vous suivrez plutôt les étapes suivantes pour avoir des substituts de serveurs supplémentaires :

  1. Modifier le fichier de configuration du service guix-daemon ; pour systemd, c’est normalement /etc/systemd/system/guix-daemon.service. Ajouter l’option --substitute-urls à la ligne de command guix-daemon et listez les URL qui vous intéressent (voir guix-daemon --substitute-urls) :
    … --substitute-urls='https://guix.example.org https://ci.guix.gnu.org'
    
  2. Redémarrez le démon. Pour systemd, cela ressemble à :
    systemctl daemon-reload
    systemctl restart guix-daemon.service
    
  3. Autorisez la clé du nouveau serveur (voir Invoquer guix archive) :
    guix archive --authorize < key.pub
    

    De nouveau, cela suppose que key.pub contient la clé publique que guix.example.org utilise pour signer les substituts.

Maintenant vous êtes paré ! Les substituts seront téléchargés de préférence à partir de https://guix.example.org, avec ci.guix.gnu.org en réserve. Évidemment vous pouvez lister autant de serveurs de substituts que vous voulez, avec l’inconvénient que la recherche de substituts sera ralentie si vous devez contacter trop de serveurs.

Remarquez qu’il à des situations où vous pourriez vouloir ajouter l’URL d’un serveur de substitut sans autoriser sa clé. Voir Authentification des substituts, pour comprendre ce point délicat.


Suivant: , Précédent: , Monter: Substituts   [Table des matières][Index]

5.3.4 Authentification des substituts

Guix détecte et lève une erreur lorsqu’il essaye d’utiliser un substitut qui a été modifié. De même, il ignore les substituts qui ne sont pas signés ou qui ne sont pas signés par l’une des clefs listées dans l’ACL.

Il y a une exception cependant : si un serveur non autorisé fournit des substituts qui sont identiques bit-à-bit à ceux fournis par un serveur autorisé, alors le serveur non autorisé devient disponible pour les téléchargements. Par exemple en supposant qu’on a choisi deux serveurs de substituts avec cette option :

--substitute-urls="https://a.example.org https://b.example.org"

Si l’ACL contient uniquement la clef de ‘b.example.org’, et si ‘a.example.org’ sert exactement les mêmes substituts, alors Guix téléchargera les substituts de ‘a.example.org’ parce qu’il vient en premier dans la liste et peut être considéré comme un miroir de ‘b.example.org’. En pratique, les machines de construction indépendantes produisent généralement les mêmes binaires, grâce à des constructions reproductibles au bit près (voir ci-dessous).

Lorsque vous utilisez HTTPS, le certificat X.509 du serveur n’est pas validé (en d’autre termes, le serveur n’est pas authentifié), contrairement à ce que des clients HTTPS comme des navigateurs web font habituellement. Celà est dû au fait que Guix authentifie les informations sur les substituts eux-mêmes, comme expliqué plus haut, ce dont on se soucie réellement (alors que les certificats X.509 authentifient la relation entre nom de domaine et clef publique).


Suivant: , Précédent: , Monter: Substituts   [Table des matières][Index]

5.3.5 Paramètres de serveur mandataire

Substitutes are downloaded over HTTP or HTTPS. The http_proxy and https_proxy environment variables can be set in the environment of guix-daemon and are honored for downloads of substitutes. Note that the value of those environment variables in the environment where guix build, guix package, and other client commands are run has absolutely no effect.


Suivant: , Précédent: , Monter: Substituts   [Table des matières][Index]

5.3.6 Échec de substitution

Même lorsqu’un substitut pour une dérivation est disponible, la substitution échoue parfois. Cela peut arriver pour plusieurs raisons : le serveur de substitut peut être hors ligne, le substitut a récemment été supprimé du serveur, la connexion peut avoir été interrompue, etc.

Lorsque les substituts sont activés et qu’un substitut pour une dérivation est disponible, mais que la tentative de substitution échoue, Guix essaiera de construire la dérivation localement si --fallback a été passé en argument (voir common build option --fallback). Plus spécifiquement, si cet option n’a pas été passée en argument, alors aucune construction locale n’est effectuée et la dérivation est considérée comme étant en échec. Cependant, si --fallback est passé en argument, alors Guix essaiera de construire la dérivation localement et l’échec ou le succès de la dérivation dépend de l’échec ou du succès de la construction locale. Remarquez que lorsque les substituts sont désactivés ou qu’aucun substitut n’est disponible pour la dérivation en question, une construction locale sera toujours effectuée, indépendamment du fait que l’argument --fallback ait été ou non passé.

Pour se donner une idée du nombre de substituts disponibles maintenant, vous pouvez essayer de lancer la commande guix weather (voir Invoquer guix weather). Cette command fournit des statistiques sur les substituts fournis par un serveur.


Précédent: , Monter: Substituts   [Table des matières][Index]

5.3.7 De la confiance en des binaires

De nos jours, le contrôle individuel sur son utilisation propre de l’informatique est à la merci d’institutions, de sociétés et de groupes avec assez de pouvoir et de détermination pour contourner les infrastructures informatiques et exploiter leurs faiblesses. Bien qu’utiliser les substituts de ci.guix.gnu.org soit pratique, nous encourageons chacun·e à construire aussi par soi-même, voire à faire tourner sa propre ferme de construction, pour que ci.guix.gnu.org devienne une cible moins intéressante. Une façon d’aider est de publier les logiciels que vous construisez avec guix publish pour que les autres aient plus de choix de serveurs où télécharger les substituts (voir Invoquer guix publish).

Guix possède les fondations pour maximiser la reproductibilité logicielle (voir Fonctionnalités). Dans la plupart des cas, des constructions indépendantes d’un paquet donnée ou d’une dérivation devrait donner des résultats identiques au bit près. Ainsi, à travers un ensemble de constructions de paquets indépendantes il est possible de renforcer l’intégrité du système. La commande guix challenge a pour but d’aider les utilisateur·rice·s à tester les serveurs de substituts et à aider les développeur·euse·s à trouver les constructions de paquets non-déterministes (voir Invoquer guix challenge). De même, l’option --check de guix build permet à chaque personne de vérifier si les substituts précédemment installés sont authentiques en les reconstruisant localement (voir guix build --check).

À l’avenir, nous aimerions que Guix puisse publier et recevoir des binaires d’autres personnes, de manière pair-à-pair. Si vous voulez discuter de ce projet, rejoignez-nous sur guix-devel@gnu.org.


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.4 Des paquets avec plusieurs résultats

Souvent, les paquets définis dans Guix ont une seule sortie — c.-à-d. que le paquet source conduit à exactement un répertoire dans le dépôt. Lorsque vous lancez guix install glibc, vous installez la sortie par défaut du paquet GNU libc ; la sortie par défaut est appelée out mais son nom peut être omis comme le montre cette commande. Dans ce cas particulier, la sortie par défaut de glibc contient tous les fichiers d’en-tête C, les bibliothèques partagées, les bibliothèques statiques, la documentation Info et les autres fichiers de support.

Parfois il est plus approprié de séparer les divers types de fichiers produits par un même paquet source en plusieurs sorties. Par exemple, la bibliothèque C GLib (utilisée par GTK+ et des paquets associés) installe plus de 20 Mo de documentation de référence dans des pages HTML. Pour préserver l’espace disque des utilisateurs qui n’en ont pas besoin, la documentation va dans une sortie séparée nommée doc. Pour installer la sortie principale de GLib, qui contient tout sauf la documentation, on devrait lancer :

guix install glib

La commande pour installer la documentation est :

guix install glib:doc

Certains paquets installent des programmes avec des « empreintes dépendances » différentes. Par exemple le paquet WordNet installe à la fois les outils en ligne de commande et les interfaces graphiques (GUI). La première ne dépend que de la bibliothèque C, alors que cette dernière dépend de Tcl/Tk et des bibliothèques X sous-jacentes. Dans ce cas, nous laissons les outils en ligne de commande dans la sortie par défaut et l’interface graphique dans une sortie séparée. Cela permet aux utilisateurs qui n’ont pas besoin d’interface graphique de gagner de la place. La commande guix size peut aider à trouver ces situations (voir Invoquer guix size). guix graph peut aussi être utile (voir Invoquer guix graph).

Il y a plusieurs paquets à sorties multiples dans la distribution GNU. D’autres noms de sorties conventionnels sont lib pour les bibliothèques et éventuellement les fichiers d’en-tête, bin pour les programmes indépendants et debug pour les informations de débogage (voir Installer les fichiers de débogage). Les sorties d’un paquet sont listés dans la troisième colonne de la sortie de guix package --list-available (voir Invoquer guix package).


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.5 Invoquer guix gc

Les paquets qui sont installés mais pas utilisés peuvent être glanés. La commande guix gc permet aux utilisateurs de lancer explicitement le ramasse-miettes pour récupérer de l’espace dans le répertoire /gnu/store. C’est la seule manière de supprimer des fichiers de /gnu/store — supprimer des fichiers ou des répertoires à la main peut le casser de manière impossible à réparer !

Le ramasse-miettes a un ensemble de racines connues : tout fichier dans /gnu/store atteignable depuis une racine est considéré comme utilisé et ne peut pas être supprimé ; tous les autres fichiers sont considérés comme inutilisés et peuvent être supprimés. L’ensemble des racines du ramasse-miettes (ou « racines du GC » pour faire court) inclue les profils par défaut des utilisateurs ; par défaut les liens symboliques sous /var/guix/gcroots représentent ces racines du GC. De nouvelles racines du GC peuvent être ajoutées avec la guix build -- root par exemple (voir Invoquer guix build). La commande guix gc --list-roots permet de les lister.

Avant de lancer guix gc --collect-garbage pour faire de la place, c’est souvent utile de supprimer les anciennes génération des profils utilisateurs ; de cette façon les anciennes constructions de paquets référencées par ces générations peuvent être glanées. Cela se fait en lançant guix package --delete-generations (voir Invoquer guix package).

Nous recommandons de lancer le ramasse-miettes régulièrement ou lorsque vous avez besoin d’espace disque. Par exemple pour garantir qu’au moins 5 Go d’espace reste libre sur votre disque, lancez simplement :

guix gc -F 5G

Il est parfaitement possible de le lancer comme une tâche périodique non-interactive (voir Exécution de tâches planifiées pour apprendre comment paramétrer une telle tâche). Lancer guix gc sans argument ramassera autant de miettes que possible mais ça n’est pas le plus pratique : vous pourriez vous retrouver à reconstruire ou re-télécharger des logiciels « inutilisés » du point de vu du GC mais qui sont nécessaires pour construire d’autres logiciels — p. ex. la chaîne de compilation.

La commande guix gc a trois modes d’opération : elle peut être utilisée pour glaner des fichiers inutilisés (par défaut), pour supprimer des fichiers spécifiques (l’option --delete), pour afficher des informations sur le ramasse-miettes ou pour des requêtes plus avancées. Les options du ramasse-miettes sont :

--collect-garbage[=min]
-C [min]

Ramasse les miettes — c.-à-d. les fichiers inaccessibles de /gnu/store et ses sous-répertoires. C’est l’opération par défaut lorsqu’aucune option n’est spécifiée.

Lorsque min est donné, s’arrêter une fois que min octets ont été collectés. min peut être un nombre d’octets ou inclure un suffixe d’unité, comme MiB pour mébioctet et GB pour gigaoctet (voir size specifications dans GNU Coreutils).

Lorsque min est omis, tout glaner.

--free-space=libre
-F libre

Glaner jusqu’à ce que libre espace soit disponible dans /gnu/store si possible ; libre est une quantité de stockage comme 500MiB comme décrit ci-dessus.

Lorsque libre ou plus est disponible dans /gnu/store ne rien faire et s’arrêter immédiatement.

--delete-generations[=durée]
-d [durée]

Avant de commencer le glanage, supprimer toutes les générations plus vielles que durée, pour tous les profils utilisateurs ; lorsque cela est lancé en root, cela s’applique à tous les profils de tous les utilisateurs.

Par exemple, cette commande supprime toutes les générations de tous vos profils plus vieilles que 2 mois (sauf s’il s’agit de la génération actuelle) puis libère de l’espace jusqu’à atteindre au moins 10 Go d’espace libre :

guix gc -d 2m -F 10G
--delete
-D

Essayer de supprimer tous les fichiers et les répertoires du dépôt spécifiés en argument. Cela échoue si certains des fichiers ne sont pas dans le dépôt ou s’ils sont toujours utilisés.

--list-failures

Lister les éléments du dépôt qui correspondent à des échecs de construction.

Cela n’affiche rien à moins que le démon n’ait été démarré avec --cache-failures (voir --cache-failures).

--list-roots

Lister les racines du GC appartenant à l’utilisateur ; lorsque la commande est lancée en root, lister toutes les racines du GC.

--list-busy

Liste des éléments de stockage utilisés par les processus en cours d’exécution. Ces éléments de stockage sont effectivement considérés comme des racines GC : ils ne peuvent pas être supprimés.

--clear-failures

Supprimer les éléments du dépôt spécifiés du cache des constructions échouées.

De nouveau, cette option ne fait de sens que lorsque le démon est démarré avec --cache-failures. Autrement elle ne fait rien.

--list-dead

Montrer la liste des fichiers et des répertoires inutilisés encore présents dans le dépôt — c.-à-d. les fichiers et les répertoires qui ne sont plus atteignables par aucune racine.

--list-live

Montrer la liste des fichiers et des répertoires du dépôt utilisés.

En plus, les références entre les fichiers existants du dépôt peuvent être demandés :

--references
--referrers

Lister les références (respectivement les référents) des fichiers du dépôt en argument.

--requisites
-R

Lister les prérequis des fichiers du dépôt passés en argument. Les prérequis sont le fichier du dépôt lui-même, leur références et les références de ces références, récursivement. En d’autre termes, la liste retournée est la closure transitive des fichiers du dépôt.

Voir Invoquer guix size pour un outil pour surveiller la taille de la closure d’un élément. Voir Invoquer guix graph pour un outil pour visualiser le graphe des références.

--derivers

Renvoie les dérivations menant aux éléments du dépôt donnés (voir Dérivations).

Par exemple cette commande :

guix gc --derivers `guix package -I ^emacs$ | cut -f4`

renvoie les fichiers .drv menant au paquet emacs installé dans votre profil.

Remarquez qu’il peut n’y avoir aucun fichier .drv par exemple quand ces fichiers ont été glanés. Il peut aussi y avoir plus d’un fichier .drv correspondant à cause de dérivations à sortie fixées.

Enfin, les options suivantes vous permettent de vérifier l’intégrité du dépôt et de contrôler l’utilisation du disque.

--verify[=options]

Vérifier l’intégrité du dépôt.

Par défaut, s’assurer que tous les éléments du dépôt marqués comme valides dans la base de données du démon existent bien dans /gnu/store.

Lorsqu’elle est fournie, l’option doit être une liste séparée par des virgule de l’un ou plus parmi contents et repair.

Lorsque vous passez --verify=contents, le démon calcul le hash du contenu de chaque élément du dépôt et le compare au hash de sa base de données. Les différences de hash sont rapportées comme des corruptions de données. Comme elle traverse tous les fichiers du dépôt, cette commande peut prendre très longtemps pour terminer, surtout sur un système avec un disque lent.

Utiliser --verify=repair ou --verify=contents,repair fait que le démon essaie de réparer les objets du dépôt corrompus en récupérant leurs substituts (voir Substituts). Comme la réparation n’est pas atomique et donc potentiellement dangereuse, elle n’est disponible que pour l’administrateur système. Une alternative plus légère lorsque vous connaissez exactement quelle entrée est corrompue consiste à lancer guix build --repair (voir Invoquer guix build).

--optimize

Optimiser le dépôt en liant en dur les fichiers identiques — c’est la déduplication.

Le démon effectue une déduplication après chaque import d’archive ou construction réussie, à moins qu’il n’ait été lancé avec --disable-deduplication (voir --disable-deduplication). Ainsi, cette option est surtout utile lorsque le démon tourne avec --disable-deduplication.


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.6 Invoquer guix pull

Les paquets sont installés ou mis à jour vers la dernière version disponible dans la distribution active sur votre machine locale. Pour mettre à jour cette distribution, en même temps que les outils Guix, vous devez lancer guix pull ; la commande télécharge le dernier code source de Guix ainsi que des descriptions de paquets, et le déploie. Le code source est téléchargé depuis un dépôt Git, par défaut le dépôt officiel de GNU Guix, bien que cela puisse être personnalisé. guix pull garantit que le code téléchargé est authentique en vérifiant que les commits sont signés par les développeur·euse·s de Guix.

Spécifiquement, guix pull télécharge le code depuis les canaux (voir voir Canaux) spécifiés par un des points suivants, dans cet ordre :

  1. l’option --channels;
  2. le fichier utilisateur·rice ~/.config/guix/channels.scm;
  3. le fichier de l’ensemble du système /etc/guix/channels.scm;
  4. les canaux intégrés par défaut spécifiés dans la variable %default-channels.

À la fin, guix package utilisera les paquets et les versions des paquets de la copie de Guix tout juste récupérée. Non seulement ça, mais toutes les commandes Guix et les modules Scheme seront aussi récupérés depuis la dernière version. Les nouvelles sous-commandes de guix ajoutés par la mise à jour sont aussi maintenant disponibles.

Chaque utilisateur peut mettre à jour sa copie de Guix avec guix pull et l’effet est limité à l’utilisateur qui a lancé guix pull. Par exemple, lorsque l’utilisateur root lance guix pull, cela n’a pas d’effet sur la version de Guix que voit alice et vice-versa.

Le résultat après avoir lancé guix pull est un profil disponible sous ~/.config/guix/current contenant la dernière version de Guix. Ainsi, assurez-vous de l’ajouter au début de votre chemin de recherche pour que vous utilisiez la dernière version. Le même conseil s’applique au manuel Info (voir Documentation) :

export PATH="$HOME/.config/guix/current/bin:$PATH"
export INFOPATH="$HOME/.config/guix/current/share/info:$INFOPATH"

L’option --list-generations ou -l liste les anciennes générations produites par guix pull, avec des détails sur leur origine :

$ guix pull -l
Génération 1	10 juin 2018 00:18:18
  guix 65956ad
    URL du dépôt : https://git.savannah.gnu.org/git/guix.git
    branche : origin/master
    commit : 65956ad3526ba09e1f7a40722c96c6ef7c0936fe

Génération 2	11 juin 2018 11:02:49
  guix e0cc7f6
    URL du dépôt : https://git.savannah.gnu.org/git/guix.git
    branche : origin/master
    commit : e0cc7f669bec22c37481dd03a7941c7d11a64f1d
  2 nouveaux paquets : keepalived, libnfnetlink
  6 paquets mis à jour : emacs-nix-mode@2.0.4,
    guile2.0-guix@0.14.0-12.77a1aac, guix@0.14.0-12.77a1aac,
    heimdal@7.5.0, milkytracker@1.02.00, nix@2.0.4

Génération 3	13 juin 2018 23:31:07	(actuelle)
  guix 844cc1c
    URL du dépôt : https://git.savannah.gnu.org/git/guix.git
    branche : origin/master
    commit : 844cc1c8f394f03b404c5bb3aee086922373490c
  28 nouveaux paquets : emacs-helm-ls-git, emacs-helm-mu, …
  69 paquets mis à jour : borg@1.1.6, cheese@3.28.0, …

Voir guix describe, pour d’autres manières de décrire le statut actuel de Guix.

This ~/.config/guix/current profile works exactly like the profiles created by guix package (voir Invoquer guix package). That is, you can list generations, roll back to the previous generation—i.e., the previous Guix—and so on:

$ guix pull --roll-back
passé de la génération 3 à 2
$ guix pull --delete-generations=1
supperssion de /var/guix/profiles/per-user/charlie/current-guix-1-link

Vous pouvez aussi utiliser guix package (voir Invoquer guix package) pour contrôler le profil en le nommant explicitement :

$ guix package -p ~/.config/guix/current --roll-back
passé de la génération 3 à 2
$ guix package -p ~/.config/guix/current --delete-generations=1
suppression de /var/guix/profiles/per-user/charlie/current-guix-1-link

La commande guix pull est typiquement invoquée sans arguments mais elle prend en charge les options suivantes :

--url=url
--commit=commit
--branch=branche

Télécharger le code pour le canal guix depuis l’url spécifié, au commit donné (un commit Git valide représenté par une chaîne hexadécimale) ou à la branche branch.

Ces options sont fournies pour votre confort, mais vous pouvez aussi spécifier votre configuration dans le fichier ~/.config/guix/channels.scm ou en utilisant l’option --channels (voir plus bas).

--channels=file
-C file

Lit la liste des canaux dans file plutôt que dans ~/.config/guix/channels.scm ou /etc/guix/channels.scm. file doit contenir un code Scheme qui s’évalue en une liste d’objets de canaux. Voir Canaux pour plus d’informations.

--news
-N

Afficher la liste des paquets ajoutés ou mis à jour depuis la génération précédente, ainsi que, occasionnellement, les nouvelles écrites par les auteur·e·s des chaînes pour leurs utilisateur·rice·s (voir Writing Channel News).

Les informations sur les paquets sont les mêmes que celles présentées à la fin de guix pull, mais sans les points de suspension, et sont aussi similaires à celles présentées par guix pull -l pour la dernière génération (voir plus bas).

--list-generations[=motif]
-l [motif]

Liste toutes les générations de ~/.config/guix/current ou, si motif est fournit, le sous-ensemble des générations qui correspondent à motif. La syntaxe de motif est la même qu’avec guix package --list-generations (voir Invoquer guix package).

--roll-back

Revenir à la génération précédente de ~/.config/guix/current c.-à-d. défaire la dernière transaction.

--switch-generation=motif
-S motif

Basculer vers une génération particulière définie par le motif.

Le motif peut être soit un numéro de génération soit un nombre précédé de « + » ou « - ». Ce dernier signifie : se déplacer en avant ou en arrière d’un nombre donné de générations. Par exemple, si vous voulez retourner à la dernière génération après --roll-back, utilisez --switch-generation=+1.

--delete-generations[=motif]
-d [motif]

Lorsque motif est omis, supprimer toutes les générations en dehors de l’actuelle.

Cette commande accepte les même motifs que --list-generations. Lorsque motif est spécifié, supprime les générations correspondantes. Lorsque motif spécifie une durée, les générations plus anciennes que la durée spécifiée correspondent. Par exemple --delete-generations=1m supprime les générations vieilles de plus d’un mois.

Si la génération actuelle correspond, elle n’est pas supprimée.

Remarquez que supprimer des générations empêche de revenir en arrière vers elles. Ainsi, cette commande doit être utilisée avec précaution.

Voir Invoquer guix describe, pour une manière d’afficher des informations sur la génération actuelle uniquement.

--profile=profil
-p profil

Utiliser le profil à la place de ~/.config/guix/current.

--dry-run
-n

Montrer quels commits des canaux seraient utilisés et ce qui serait construit ou substitué mais ne pas le faire vraiment.

--allow-downgrades

Permet d’extraire des révisions de canaux plus anciennes ou sans rapport avec celles qui sont actuellement utilisées.

Par défaut, guix pull protège contre les attaques dites de "downgrade", par lesquelles le dépôt Git d’un canal serait réinitialisé à une révision antérieure ou sans rapport avec lui-même, ce qui pourrait vous conduire à installer des versions plus anciennes de paquets logiciels, ou connues pour être vulnérables.

Remarque : Assurez-vous de comprendre les implications de sa sécurité avant d’utiliser --allow-downgrades.

--disable-authentication

Permet de "tirer" le code du canal sans l’authentifier.

Par défaut, guix pull authentifie le code téléchargé depuis les canaux en vérifiant que ses commits sont signés par les développeur·euse·s, et renvoie une erreur si ce n’est pas le cas. Cette option lui enjoint de ne pas effectuer une telle vérification.

Remarque : Assurez-vous de comprendre les implications de sa sécurité avant d’utiliser --disable-authentication.

--system=système
-s système

Tenter de construire pour le système — p. ex. i686-linux — plutôt que pour le type de système de l’hôte de construction.

--bootstrap

Utiliser le programme d’amorçage Guile pour construire la dernière version de Guix. Cette option n’est utile qu’aux personnes qui développent Guix.

Le mécanisme de canaux vous permet de dire à guix pull quels répertoires et branches récupérer, ainsi que les dépôts supplémentaires contenant des modules de paquets qui devraient être déployés. Voir Canaux pour plus d’information.

En plus, guix pull supporte toutes les options de construction communes (voir Options de construction communes).


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.7 Invoquer guix time-machine

La commande guix time-machine donne accès à d’autres révisions de Guix, par exemple pour installer d’anciennes versions de paquets, ou pour reproduire un calcul dans un environnement identique. La révision de Guix à utiliser est définie par un commit ou par un fichier de description de canal créé par guix describe (voir Invoquer guix describe).

La syntaxe générale est :

guix time-machine options… -- commande arg

command et arg… sont passés sans modification à la commande guix de la révision spécifiée. Les options qui définissent cette révision sont les mêmes que pour la commande guix pull (voir Invoquer guix pull) :

--url=url
--commit=commit
--branch=branche

Utiliser le canal guix depuis l’url spécifiée, au commit donné (un commit Git valide représenté par une chaîne hexadécimale) ou à la branche branch.

--channels=file
-C file

Lit la liste des canaux dans file. file doit contenir un code Scheme qui s’évalue en une liste d’objets de canaux. Voir Canaux pour plus d’informations.

As for guix pull, the absence of any options means that the latest commit on the master branch will be used. The command

guix time-machine -- build hello

va donc construire le paquet hello tel que défini dans la branche master, qui est en général une révision de Guix plus récente que celle que vous avez installée. Le voyage dans le temps fonctionne dans les deux sens !

Remarquez que guix time-machine peut lancer des constructions de canaux et de leurs dépendances, et qu’elles peuvent être contrôlées avec les options de construction communes (voir Options de construction communes).


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.8 Inférieurs

Remarque : La fonctionnalité décrite ici est un « démonstrateur technique » à la version 1.2.0. Ainsi, l’interface est sujette à changements.

Parfois vous pourriez avoir à mélanger des paquets de votre révision de Guix avec des paquets disponibles dans une révision différente de Guix. Les inférieurs de Guix vous permettent d’accomplir cette tâche en composant différentes versions de Guix de manière arbitraire.

Techniquement, un « inférieur » est surtout un processus Guix séparé connecté à votre processus Guix principal à travers un REPL (voir Invoquer guix repl). Le module (guix inferior) vous permet de créer des inférieurs et de communiquer avec eux. Il fournit aussi une interface de haut-niveau pour naviguer dans les paquets d’un inférieur — des paquets inférieurs — et les manipuler.

Lorsqu’on les combine avec des canaux (voir Canaux), les inférieurs fournissent une manière simple d’interagir avec un révision de Guix séparée. Par exemple, disons que vous souhaitiez installer dans votre profil le paquet guile actuel, avec le guile-json d’une ancienne révision de Guix — peut-être parce que la nouvelle version de guile-json a une API incompatible et que vous voulez lancer du code avec l’ancienne API. Pour cela, vous pourriez écrire un manifeste à utiliser avec guix package --manifest (voir Invoquer guix package) ; dans ce manifeste, vous créeriez un inférieur pour l’ancienne révision de Guix qui vous intéresse et vous chercheriez le paquet guile-json dans l’inférieur :

(use-modules (guix inferior) (guix channels)
             (srfi srfi-1))   ;pour « first »

(define channels
  ;; L'ancienne révision depuis laquelle on veut
  ;; extraire guile-json.
  (list (channel
         (name 'guix)
         (url "https://git.savannah.gnu.org/git/guix.git")
         (commit
          "65956ad3526ba09e1f7a40722c96c6ef7c0936fe"))))

(define inferior
  ;; Un inférieur représentant la révision ci-dessus.
  (inferior-for-channels channels))

;; Maintenant on crée un manifeste avec le paquet « guile » actuel
;; et l'ancien paquet « guile-json ».
(packages->manifest
 (list (first (lookup-inferior-packages inferior "guile-json"))
       (specification->package "guile")))

Durant la première exécution, guix package --manifest pourrait avoir besoin de construire le canal que vous avez spécifié avant de créer l’inférieur ; les exécutions suivantes seront bien plus rapides parce que la révision de Guix sera déjà en cache.

Le module (guix inferior) fournit les procédures suivantes pour ouvrir un inférieur :

Procédure Scheme : inferior-for-channels channels [#:cache-directory] [#:ttl]

Renvoie un inférieur pour channels, une liste de canaux. Elle utilise le cache dans cache-directory, où les entrées peuvent être glanées après ttl secondes. Cette procédure ouvre une nouvelle connexion au démon de construction.

Elle a pour effet de bord de construire ou de substituer des binaires pour channels, ce qui peut prendre du temps.

Procédure Scheme : open-inferior directory [#:command "bin/guix"]

Ouvre le Guix inférieur dans directory et lance directory/command repl ou équivalent. Renvoie #f si l’inférieur n’a pas pu être lancé.

Les procédures listées plus bas vous permettent d’obtenir et de manipuler des paquets inférieurs.

Procédure Scheme : inferior-packages inferior

Renvoie la liste des paquets connus de l’inférieur inferior.

Procédure Scheme : lookup-inferior-packages inferior name [version]

Renvoie la liste triée des paquets inférieurs qui correspondent à name dans inferior, avec le plus haut numéro de version en premier. Si version est vrai, renvoie seulement les paquets avec un numéro de version préfixé par version.

Procédure Scheme : inferior-package? obj

Renvoie vrai si obj est un paquet inférieur.

Procédure Scheme : inferior-package-name package
Procédure Scheme : inferior-package-version package
Procédure Scheme : inferior-package-synopsis package
Procédure Scheme : inferior-package-description package
Procédure Scheme : inferior-package-home-page package
Procédure Scheme : inferior-package-location package
Procédure Scheme : inferior-package-inputs package
Procédure Scheme : inferior-package-native-inputs package
Procédure Scheme : inferior-package-propagated-inputs package
Procédure Scheme : inferior-package-transitive-propagated-inputs package
Procédure Scheme : inferior-package-native-search-paths package
Procédure Scheme : inferior-package-transitive-native-search-paths package
Procédure Scheme : inferior-package-search-paths package

Ces procédures sont la contrepartie des accesseurs des enregistrements de paquets (voir référence des paquets). La plupart fonctionne en effectuant des requêtes à l’inférieur dont provient package, donc l’inférieur doit toujours être disponible lorsque vous appelez ces procédures.

Les paquets inférieurs peuvent être utilisés de manière transparente comme tout autre paquet ou objet simili-fichier dans des G-expressions (voir G-Expressions). Ils sont aussi gérés de manière transparente par la procédure packages->manifest, qui est typiquement utilisée dans des manifestes (voir l’option --manifest de guix package). Ainsi, vous pouvez insérer un paquet inférieur à peu près n’importe où vous utiliseriez un paquet normal : dans des manifestes, dans le champ packages de votre déclaration operating-system, etc.


Suivant: , Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.9 Invoquer guix describe

Souvent vous voudrez répondre à des questions comme « quelle révision de Guix j’utilise ? » ou « quels canaux est-ce que j’utilise ? ». C’est une information utile dans de nombreuses situations : si vous voulez répliquer un environnement sur une machine différente ou un compte utilisateur, si vous voulez rapporter un bogue ou pour déterminer quel changement dans les canaux que vous utilisez l’a causé ou si vous voulez enregistrer l’état de votre système pour le reproduire. La commande guix describe répond à ces questions.

Lorsqu’elle est lancée depuis un guix mis à jour avec guix pull, guix describe affiche les canaux qui ont été construits, avec l’URL de leur dépôt et l’ID de leur commit (voir Canaux) :

$ guix describe
Generation 10	03 sep. 2018 17:32:44	(actuelle)
  guix e0fa68c
    URL du dépôt : https://git.savannah.gnu.org/git/guix.git
    branche : master
    commit : e0fa68c7718fffd33d81af415279d6ddb518f727

Si vous connaissez bien le système de contrôle de version Git, cela ressemble en essence à git describe ; la sortie est aussi similaire à celle de guix pull --list-generations, mais limitée à la génération actuelle (voir l’option --list-generations). Comme l’ID de commit de Git ci-dessus se réfère sans aucune ambiguïté à un instantané de Guix, cette information est tout ce dont vous avez besoin pour décrire la révision de Guix que vous utilisez et pour la répliquer.

Pour rendre plus facile la réplication de Guix, guix describe peut aussi renvoyer une liste de canaux plutôt que la description lisible par un humain au-dessus :

$ guix describe -f channels
(list (channel
        (name 'guix)
        (url "https://git.savannah.gnu.org/git/guix.git")
        (commit
          "e0fa68c7718fffd33d81af415279d6ddb518f727")))
        (introduction
          (make-channel-introduction
            "9edb3f66fd807b096b48283debdcddccfea34bad"
            (openpgp-fingerprint
              "BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA")))))

Vous pouvez sauvegarder ceci dans un fichier et le donner à guix pull -C sur une autre machine ou plus tard, ce qui instantiera exactement la même révision de Guix (voir l’option -C). À partir de là, comme vous pouvez déployer la même révision de Guix, vous pouvez aussi bien répliquer un environnement logiciel complet. Nous pensons humblement que c’est génial, et nous espérons que vous aimerez ça aussi !

Voici les détails des options supportées par guix describe :

--format=format
-f format

Produire la sortie dans le format donné, parmi :

human

produire une sortie lisible par un humain ;

canaux

produire une liste de spécifications de canaux qui peut être passée à guix pull -C ou installée dans ~/.config/guix/channels.scm (voir Invoquer guix pull) ;

channels-sans-intro

comme canaux, mais oubliez le champ introduction ; utilisez-le pour produire une spécification de canal adaptée à la version 1.1.0 ou antérieure de Guix–le champ introduction concerne l’authentification des canaux (voir Channel Authentication) et n’est pas pris en charge par ces versions antérieures ;

json

produire une liste de spécifications de canaux dans le format JSON ;

recutils

produire une liste de spécifications de canaux dans le format Recutils.

--list-formats

Affiche les formats disponibles pour l’option --format.

--profile=profil
-p profil

Afficher les informations sur le profil.


Précédent: , Monter: Gestion de paquets   [Table des matières][Index]

5.10 Invoquer guix archive

La commande guix archive permet aux utilisateurs d’exporter des fichiers du dépôt dans une simple archive puis ensuite de les importer sur une machine qui fait tourner Guix. En particulier, elle permet de transférer des fichiers du dépôt d’une machine vers le dépôt d’une autre machine.

Remarque : Si vous chercher une manière de produire des archives dans un format adapté pour des outils autres que Guix, voir Invoquer guix pack.

Pour exporter des fichiers du dépôt comme une archive sur la sortie standard, lancez :

guix archive --export options spécifications...

spécifications peut être soit des noms de fichiers soit des spécifications de paquets, comme pour guix package (voir Invoquer guix package). Par exemple, la commande suivante crée une archive contenant la sortie gui du paquet git et la sortie principale de emacs :

guix archive --export git:gui /gnu/store/...-emacs-24.3 > great.nar

Si les paquets spécifiés ne sont pas déjà construits, guix archive les construit automatiquement. Le processus de construction peut être contrôlé avec les options de construction communes (voir Options de construction communes).

Pour transférer le paquet emacs vers une machine connectée en SSH, on pourrait lancer :

guix archive --export -r emacs | ssh la-machine guix archive --import

De même, on peut transférer un profil utilisateur complet d’une machine à une autre comme cela :

guix archive --export -r $(readlink -f ~/.guix-profile) | \
  ssh the-machine guix archive --import

Toutefois, il faut noter que, dans les deux exemples, tous les emacs et le profil, ainsi que toutes leurs dépendances sont transférés (en raison de l’-r), indépendamment de ce qui est déjà disponible dans le dépôt sur la machine cible. L’option --missing peut aider à déterminer quels sont les éléments manquants dans le dépôt cible. La commande guix copy simplifie et optimise tout ce processus, c’est donc probablement ce que vous devriez utiliser dans ce cas (voir Invoquer guix copy).

Chaque élément du dépôt est écrit dans le format archive normalisée ou nar (décrit ci-dessous), et la sortie de guix archive --export (et entrée de guix archive --import) est un nar bundle.

Le format nar est comparable dans l’esprit au format "tar", mais avec des différences qui le rendent plus approprié à nos objectifs. Premièrement, plutôt que d’enregistrer toutes les métadonnées Unix pour chaque fichier, le format nar ne mentionne que le type de fichier (régulier, répertoire ou lien symbolique) ; les autorisations Unix et le propriétaire/groupe sont rejetés. Deuxièmement, l’ordre dans lequel les entrées de répertoire sont stockées, suit toujours celui des noms de fichiers selon leur vérification de concordance des locales C. Cela rend la production d’archives entièrement déterministe.

Ce format de lot nar est surtout la concaténation de zéro, un ou plusieurs nar avec des métadonnées pour chaque élément du dépôt qu’il contient : son nom de fichier, ses références, la dérivation correspondante et une signature numérique.

Lors de l’export, le démon signe numériquement le contenu de l’archive et cette signature est ajoutée à la fin du fichier. Lors de l’import, le démon vérifie la signature et rejette l’import en cas de signature invalide ou si la clef de signature n’est pas autorisée.

Les principales options sont :

--export

Exporter les fichiers ou les paquets spécifiés du dépôt (voir plus bas). Écrire l’archive résultante sur la sortie standard.

Les dépendances ne sont pas incluses dans la sortie à moins que --recursive ne soit passé.

-r
--recursive

En combinaison avec --export, cette option demande à guix archive d’inclure les dépendances des éléments donnés dans l’archive. Ainsi, l’archive résultante est autonome : elle contient la fermeture des éléments de dépôt exportés.

--import

Lire une archive depuis l’entrée standard et importer les fichiers inclus dans le dépôt. Annuler si l’archive a une signature invalide ou si elle est signée par une clef publique qui ne se trouve pas dans le clefs autorisées (voir --authorize plus bas.)

--missing

Liste une liste de noms de fichiers du dépôt sur l’entrée standard, un par ligne, et écrit sur l’entrée standard le sous-ensemble de ces fichiers qui manquent dans le dépôt.

--generate-key[=paramètres]

Génére une nouvelle paire de clefs pour le démon. C’ est un prérequis avant que les archives ne puissent être exportées avec --export. Cette opération est habituellement instantanée mais elle peut prendre du temps parce qu’elle doit récupérer suffisamment d’entropie pour générer la paire de clefs. Sur Guix System, guix-service-typeprend soin de générer cette paire de clés au premier démarrage.

La paire de clés générée est typiquement stockée dans /etc/guix, dans signing-key.pub (clé publique) et signing-key.sec (clé privée, qui doit rester secrète). Lorsque paramètres est omis, une clé ECDSA utilisant la courbe Ed25519 est générée, ou pour les version de libgcrypt avant 1.6.0, une clé RSA de 4096 bits. Autrement, paramètres peut spécifier les paramètres genkey adaptés pour libgcrypt (voir gcry_pk_genkey dans The Libgcrypt Reference Manual).

--authorize

Autoriser les imports signés par la clef publique passée sur l’entrée standard. La clef publique doit être au « format avancé s-expression » — c.-à-d. le même format que le fichier signing-key.pub.

La liste des clés autorisées est gardée dans un fichier modifiable par des humains dans /etc/guix/acl. Le fichier contient des « s-expressions au format avancé » et est structuré comme une liste de contrôle d’accès dans l’infrastructure à clefs publiques simple (SPKI).

--extract=répertoire
-x répertoire

Lit une archive à un seul élément telle que servie par un serveur de substituts (voir Substituts) et l’extrait dans répertoire. C’est une opération de bas niveau requise seulement dans de rares cas d’usage ; voir plus loin.

Par exemple, la commande suivante extrait le substitut pour Emacs servi par ci.guix.gnu.org dans /tmp/emacs :

$ wget -O - \
  https://ci.guix.gnu.org/nar/gzip/…-emacs-24.5 \
  | gunzip | guix archive -x /tmp/emacs

Les archives à un seul élément sont différentes des archives à plusieurs éléments produites par guix archive --export ; elles contiennent un seul élément du dépôt et elles n’embarquent pas de signature. Ainsi cette opération ne vérifie pas de signature et sa sortie devrait être considérée comme non sûre.

Le but principal de cette opération est de faciliter l’inspection du contenu des archives venant de serveurs auxquels on ne fait potentiellement pas confiance. (voir Invoquer guix challenge).

--list
-t

Lit une archive à un seul élément telle que servie par un serveur de substituts (voir Substituts) et affiche la liste des fichiers qu’elle contient, comme dans cet exemple :

$ wget -O - \
  https://ci.guix.gnu.org/nar/lzip/…-emacs-26.3 \
  | lzip -d | guix archive -t

Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

6 Canaux

Guix et sa collection de paquets sont mis à jour en lançant guix pull (voir Invoquer guix pull). Par défaut guix pull télécharge et déploie Guix lui-même depuis le dépôt officiel de GNU Guix. Cela peut être personnalisé en définissant des canaux dans le fichier ~/.config/guix/channels.scm. Un canal spécifie l’URL et la branche d’un répertoire Git à déployer et on peut demander à guix pull de récupérer un ou plusieurs canaux. En d’autres termes, les canaux peuvent être utilisés pour personnaliser et pour étendre Guix, comme on le verra plus bas. Guix est en mesure de prendre en compte les préoccupations de sécurité et de traiter les mises à jour authentifiées.


Suivant: , Monter: Canaux   [Table des matières][Index]

6.1 Spécifier des canaux supplémentaires

You can specify additional channels to pull from. To use a channel, write ~/.config/guix/channels.scm to instruct guix pull to pull from it in addition to the default Guix channel(s):

;; Ajouter des variantes de paquets à ceux fournis par Guix.
(cons (channel
        (name 'my-personal-packages)
        (url "https://example.org/personal-packages.git"))
      %default-channels)

Remarquez que le bout de code au-dessus est (comme toujours !) du code Scheme ; nous utilisons cons pour ajouter un canal à la liste des canaux que la variable %default-channels représente (voir cons and lists dans GNU Guile Reference Manual). Avec ce fichier en place, guix pull construit non seulement Guix mais aussi les modules de paquets de votre propre dépôt. Le résultat dans ~/.config/guix/current est l’union de Guix et de vos propres modules de paquets :

$ guix pull --list-generations
…
Génération 19	Aug 27 2018 16:20:48
  guix d894ab8
    URL du dépôt : https://git.savannah.gnu.org/git/guix.git
    branche : master
    commit : d894ab8e9bfabcefa6c49d9ba2e834dd5a73a300
  variant-packages dd3df5e
    URL du dépôt : https://example.org/personal-packages.git
    branche : master
    commit : dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb
  11 nouveaux paquets : variant-gimp, variant-emacs-with-cool-features, …
  4 paquets mis à jour : emacs-racket-mode@0.0.2-2.1b78827, …

La sortie de guix pull ci-dessus montre que la génération 19 contient aussi bien Guix que les paquets du canal variant-packages. Parmi les nouveaux paquets et les paquets mis à jour qui sont listés, certains comme variant-gimp et variant-emacs-with-cool-features peuvent provenir de variant-packages, tandis que d’autres viennent du canal par défaut de Guix.


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.2 Utiliser un canal Guix personnalisé

Le canal nommé guix spécifie où Guix lui-même — ses outils en ligne de commande ainsi que sa collection de paquets — seront téléchargés. Par exemple, supposons que vous voulez effectuer les mises à jour depuis votre propre copie du dépôt Guix sur example.org, et plus particulièrement depuis la branche super-hacks. Vous pouvez écrire cette spécification dans ~/.config/guix/channels.scm :

;; Dit à « guix pull » d'utiliser un autre dépôt.
(list (channel
        (name 'guix)
        (url "https://example.org/my-guix.git")
        (branch "super-hacks")))

Maintenant, guix pull récupérera le code depuis la branche super-hacks du dépôt sur example.org. La question de l’authentification est traitée ci-dessous ((voir Authentification des canaux).


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.3 Répliquer Guix

La sortie de guix pull --list-generations ci-dessus montre précisément quels commits ont été utilisés pour construire cette instance de Guix. Nous pouvons donc la répliquer, disons sur une autre machine, en fournissant une spécification de canal dans ~/.config/guix/channels.scm qui est « épinglé » à ces commits :

;; Déployer des commits précis de mes canaux préférés.
(list (channel
       (name 'guix)
       (url "https://git.savannah.gnu.org/git/guix.git")
       (commit "6298c3ffd9654d3231a6f25390b056483e8f407c"))
      (channel
       (name 'variant-packages)
       (url "https://example.org/variant-packages.git")
       (commit "dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb")))

La commande guix describe --format=channels peut même générer cette liste de canaux directement (voir Invoquer guix describe). Le fichier qui en résulte peut être utilisé avec l’option -C de guix pull (voir Invoquer guix pull) ou guix time-machine (voir Invoquer guix time-machine).

À ce moment les deux machines font tourner exactement le même Guix, avec l’accès exactement aux même paquets. La sortie de guix build gimp sur une machine sera exactement la même, au bit près, que la sortie de la même commande sur l’autre machine. Cela signifie aussi que les deux machines ont accès à tous les codes sources de Guix, et transitivement, à tous les codes sources de tous les paquets qu’il définit.

Cela vous donne des super-pouvoirs, ce qui vous permet de suivre la provenance des artefacts binaires avec un grain très fin et de reproduire les environnements logiciels à volonté — une sorte de capacité de « méta-reproductibilité », si vous voulez. Voir Inférieurs, pour une autre manière d’utiliser ces super-pouvoirs.


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.4 Authentification des canaux

Les commandes guix pull et guix time-machine authenticate téléchargent et contrôlent le code récupéré sur les canaux : elles s’assurent que chaque commit récupéré est signé par un·e développeur·euse autorisé·e. L’objectif est de protéger contre les modifications non autorisées du canal qui conduiraient les utilisateur·rice·s à exécuter du code malveillant.

En tant qu’utilisateur, vous devez fournir une introduction de canal dans votre fichier de canaux afin que Guix sache comment authentifier son premier commit. Une spécification de canal, y compris son introduction, ressemble à quelque chose de ce genre :

(channel
  (name 'some-channel)
  (url "https://example.org/some-channel.git")
  (introduction
   (make-channel-introduction
    "6f0d8cc0d88abb59c324b2990bfee2876016bb86"
    (openpgp-fingerprint
     "CABB A931 C0FF EEC6 900D  0CFB 090B 1199 3D9A EBB5"))))

La spécification ci-dessus indique le nom et l’URL du canal. L’appel à make-channel-introduction ci-dessus spécifie que l’authentification de ce canal commence au commit 6f0d8cc…, qui est signé par la clé OpenPGP avec l’empreinte digitale CABB A931….

Pour le canal principal, appelé guix, vous obtenez automatiquement cette information à partir de votre installation de Guix. Pour les autres canaux, incluez l’introduction du canal fournie par les auteurs du canal dans votre fichier channels.scm. Assurez-vous de récupérer l’introduction du canal à partir d’une source fiable, car c’est la base de votre confiance.

Si vous êtes curieux·euse à propos des mécanismes d’authentification, lisez !


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.5 Écrire de nouveaux de canaux

Disons que vous avez un ensemble de paquets personnels ou de variantes personnalisées dont vous pensez qu’il ne vaudrait pas le coup de contribuer au projet Guix, mais que vous voudriez pouvoir utiliser de manière transparente sur la ligne de commande : vous écririez d’abord des modules contenant ces définitions de paquets (voir Modules de paquets), en les maintenant dans un dépôt Git, puis vous ou n’importe qui d’autre pourrait l’utiliser comme un canal supplémentaire où trouver ces paquets. Sympa, non ?

Attention : Avant que vous, cher utilisateur, ne vous exclamiez « Oh mais c’est super génial ! » et que vous ne publiez vos canaux personnels publiquement, nous voudrions vous donner quelques avertissements :

Vous avez été prévenus ! Maintenant, nous pensons que des canaux externes sont une manière pratique d’exercer votre liberté pour augmenter la collection de paquets de Guix et de partager vos améliorations, qui sont les principes de bases du logiciel libre. Contactez-nous par courriel sur guix-devel@gnu.org si vous souhaitez discuter à ce propos.

Pour créer un canal, créez un dépôt Git contenant vos propres modules de paquets et rendez-le disponible. Le dépôt peut contenir tout ce que vous voulez, mais un canal utile contiendra des modules Guile qui exportent des paquets. Une fois que vous avez démarré un canal, Guix se comportera comme si le répertoire de la racine du dépôt Git de ce canal était ajouté au chemin de chargement de Guile (voir Load Paths dans GNU Guile Reference Manual). Par exemple, si votre canal contient un fichier mes-paquets/mes-outils.scm qui définit un module Guile, le module sera disponible sous le nom de (mes-paquets mes-outils) et vous pourrez l’utiliser comme les autres modules (voir Modules dans GNU Guile Reference Manual).

En tant qu’auteur.e d’un canal, envisagez de regrouper le nécessaire d’authentification avec votre canal afin que les utilisatrice·eur·s puissent l’authentifier. Voir Authentification des canaux, et Spécifier les autorisations des canaux, pour savoir comment les utiliser.


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.6 Modules de paquets dans un sous-répertoire

En tant qu’auteur.e d’un canal, vous voudriez garder vos modules de canal dans un sous-répertoire. Si vos modules sont dans le sous-répertoire guix, vous devez ajouter un fichier de métadonnées .guix-channel qui contient :

(channel
  (version 0)
  (directory "guix"))

Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.7 Déclarer des dépendances de canaux

Les auteurs de canaux peuvent décider d’augmenter une collection de paquets fournie par d’autres canaux. Ils peuvent déclarer leur canal comme dépendant d’autres canaux dans le fichier de métadonnées .guix-channel qui doit être placé à la racine de dépôt du canal.

Le fichier de métadonnées devrait contenir une S-expression simple comme cela :

(channel
 (version 0)
 (dependencies
  (channel
   (name 'some-collection)
   (url "https://example.org/first-collection.git")

   ;; La partie « introduction » ci-dessous est facultative : vous la
   ;; fournissez pour les dépendances qui peuvent être authentifiées.
   (introduction
    (channel-introduction
      (version 0)
      (commit "a8883b58dc82e167c96506cf05095f37c2c2c6cd")
      (signer "CABB A931 C0FF EEC6 900D  0CFB 090B 1199 3D9A EBB5"))))
  (channel
   (name 'some-other-collection)
   (url "https://example.org/second-collection.git")
   (branch "testing"))))

Dans l’exemple ci-dessus, ce canal est déclaré comme dépendant de deux autres canaux, qui seront récupérés automatiquement. Les modules fournis par le canal seront compilés dans un environnement où les modules de tous les canaux déclarés sont disponibles.

Pour des raisons de fiabilité et de maintenabilité, vous devriez éviter d’avoir des dépendances sur des canaux que vous ne maîtrisez pas et vous devriez ajouter le minimum de dépendances possible.


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.8 Spécifier les autorisations des canaux

Comme nous l’avons vu plus haut, Guix garantit le code source qu’il récupère depuis les canaux venant de développeur·euse·s autorisé·e·s. En tant qu’auteur.e, vous devez spécifiez la liste des développeur·euse·s autorisé·e·s dans le fichier .guix-authorizations dans le dépôt Git des canaux. Le rôle de l’authentification est simple : chaque commit doit être signé par une clé listée dans le fichier .guix-authorizations de son (ses) commit(s) parent(s)10 Le fichier .guix-authorizations ressemble à ceci :

;; Exemple fichier '.guix-authorizations'.

(authorizations
 (version 0)               ;version actuelle du format de fichier

 (("AD17 A21E F8AE D8F1 CC02  DBD9 F8AE D8F1 765C 61E3"
   (name "alice"))
  ("2A39 3FFF 68F4 EF7A 3D29  12AF 68F4 EF7A 22FB B2D5"
   (name "bob"))
  ("CABB A931 C0FF EEC6 900D  0CFB 090B 1199 3D9A EBB5"
   (name "charlie"))))

Chaque empreinte digitale est suivie de paires de clés/valeurs facultatives, comme dans l’exemple ci-dessus. Actuellement, ces paires clé/valeur sont ignorées.

Ce rôle d’authentification crée un problème de poule-et-oeuf : comment authentifions-nous le premier commit ? Relatif à celà : comment traiter les canaux dont l’historique du dépôt contient des commits non signés et qui n’ont pas de.guix-authorisations ? Et comment bifurquer des canaux existants ?

Les présentations de canaux répondent à ces questions en décrivant le premier commit d’un canal qui doit être authentifiée. La première fois qu’un canal est récupéré avec guix pull ou guix time-machine, la commande recherche le commit d’introduction et vérifie qu’il est signé par la clé OpenPGP spécifiée. Elle authentifie ensuite les commits selon la règle ci-dessus.

De plus, votre canal doit fournir toutes les clés OpenPGP qui ont été mentionnées dans les fichiers .guix-authorizations, stockés dans les fichiers .key, qui peuvent être soit binaires soit "blindés ASCII". Par défaut, ces fichiers .key sont recherchés dans la branche nommée keyring, mais vous pouvez spécifier un nom de branche différent dans .guix-channel de cette façon :

(channel
  (version 0)
  (keyring-reference "my-keyring-branch"))

En résumé, en tant qu’auteur.e d’une chaîne, il y a trois choses que vous devez faire pour permettre aux utilisateur·rice·s d’authentifier votre code :

  1. Exporter les clés OpenPGP des committers passés et présents avec gpg -export et les stocker dans des fichiers .key, par défaut dans une branche nommée keyring (nous recommandons d’en faire une branche orpheline).
  2. Introduisez un fichier .guix-authorisations initial dans le dépôt du canal. Faites cela dans un commit signé (voir Accès en commit, pour savoir comment signer les commit Git).
  3. Annoncez l’introduction du canal, par exemple sur la page web de votre canal. L’introduction du canal, comme nous l’avons vu ci-dessus, est la paire de clés commit—c’est-à-dire le commit qui a introduit .guix-authorizations, et l’empreinte digitale de l’OpenPGP utilisé pour le signer.

Avant de pousser vers votre dépôt Git public, vous pouvez lancer guix git-authenticate pour vérifier que vous avez bien signé tous les commits que vous allez pousser avec une clé autorisée :

guix git authenticate commit signer

commit et signer sont votre présentation de canal. Voir Invoquer guix git authenticate, pour plus de détails.

Publier un canal signé demande de la discipline : toute faute, comme un commit non signé ou un commit signée par une clé non autorisée, vont empêcher les utilisateur·rice·s de récupérer depuis votre canal—bref, c’est tout l’intérêt de l’authentification ! Faites particulièrement attention aux merges : les merge commits sont considérés comme authentiques si et seulement s’ils sont signés par une clé présente dans le fichier .guix-authorizations des branches both.


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.9 URL primaire

Les auteur.e.s de canaux peuvent indiquer l’URL principale de leur dépôt Git de canal dans le fichier .guix-channel comme ceci :

(channel
  (version 0)
  (url "https://example.org/guix.git"))

This allows guix pull to determine whether it is pulling code from a mirror of the channel; when that is the case, it warns the user that the mirror might be stale and displays the primary URL. That way, users cannot be tricked into fetching code from a stale mirror that does not receive security updates.

Cette fonctionnalité n’a de sens que pour les dépôts authentifiés, tels que le canal officiel guix, pour lequel guix pull garantit l’authenticité du code qu’il récupère.


Suivant: , Précédent: , Monter: Canaux   [Table des matières][Index]

6.10 Écrire des nouveautés de canaux

Les auteur.e.s de canaux peuvent occasionnellement vouloir communiquer à leurs utilisateur·rice·s des informations au sujet de changements importants dans le canal. Vous pourriez leur envoyer un courriel, mais ce n’est pas pratique.

Au lieu de celà, les canaux peuvent fournir un fichier de nouvelles ; lorsque les utilisateur·rice·s du canal exécutent guix pull, ce fichier de nouvelles est automatiquement lu et guix pull --news peut afficher les annonces qui correspondent aux nouveaux commits qui ont été récupérés, le cas échéant.

Pour faire celà, les auteur.e.s de canal doivent en premier lieu déclarer le nom du fichier de nouvelles dans leur fichier .guix-channel :

(channel
  (version 0)
  (news-file "etc/news.txt"))

Le fichier de nouvelles lui-même, etc/news.txt dans cet exemple, doit ressembler à quelque chose comme ceci :

(channel-news
  (version 0)
  (entry (tag "the-bug-fix")
         (title (en "Fixed terrible bug")
                (fr "Oh la la"))
         (body (en "@emph{Good news}!  It's fixed!")
               (eo "Certe ĝi pli bone funkcias nun!")))
  (entry (commit "bdcabe815cd28144a2d2b4bc3c5057b051fa9906")
         (title (en "Added a great package")
                (ca "Què vol dir guix?"))
         (body (en "Don't miss the @code{hello} package!"))))

Tandis que le fichier de nouvelles utilise la syntaxe Scheme, évitez de le nommer avec une extension .scm, sinon il sera récupéré lors de la construction du canal et produira une erreur puisqu’il ne s’agit pas d’un module valide. Vous pouvez également déplacer le module du canal dans un sous-répertoire et stocker le fichier de nouvelles dans un autre répertoire.

Le fichier consiste en une liste de news entries. Chaque entrée est associée à un commit ou un tag : elle décrit les changements faits dans ce commit, éventuellement dans les commits précédents comme il faut. Les utilisateur·rice·s ne voient les entrées que la première fois qu’il·elle·s obtiennent le commit auquel l’entrée se réfère.

Le titre doit être un résumé d’une ligne tandis que body peut être arbitrairement long, et les deux peuvent contenir des balises Texinfo (voir Overview dans GNU Texinfo). Le titre et le corps sont tous deux une liste de tuples de balises/messages de langue, ce qui permet à guix pull d’afficher les nouvelles dans la langue qui correspond à la locale de l’utilisateur.

Si vous souhaitez traduire des actualités en utilisant un déroulement basé sur gettext, vous pouvez extraire des chaînes traduisibles avec xgettext (voir xgettext Invocation dans GNU Gettext Utilities). Par exemple, en supposant que vous écriviez d’abord les entrées de nouvelles en anglais, la commande ci-dessous crée un fichier PO contenant les chaînes à traduire :

xgettext -o news.po -l scheme -ken etc/news.txt

Pour résumer, oui, vous pourriez utiliser votre chaîne comme un blog. Mais attention, ce n’est pas tout à fait ce à quoi vos utilisateur·rice·s pourraient s’attendre.


Précédent: , Monter: Canaux   [Table des matières][Index]

6.11 Channels with Substitutes

When running guix pull, Guix will first compile the definitions of every available package. This is an expensive operation for which substitutes (voir Substituts) may be available. The following snippet in channels.scm will ensure that guix pull uses the latest commit with available substitutes for the package definitions: this is done by querying the continuous integration server at https://ci.guix.gnu.org.

(use-modules (guix ci))

(list (channel-with-substitutes-available
       %default-guix-channel
       "https://ci.guix.gnu.org"))

Note that this does not mean that all the packages that you will install after running guix pull will have available substitutes. It only ensures that guix pull will not try to compile package definitions. This is particularly useful when using machines with limited resources.


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

7 Développement

Si vous êtes développeur de logiciels, Guix fournit des outils que vous devriez trouver utiles — indépendamment du langage dans lequel vous développez. C’est ce dont parle ce chapitre.

La commande guix environment permet de créer des environnements de développement confortables contenant toutes les dépendances et les outils nécessaires pour travailler sur le paquet logiciel de votre choix. La commande guix pack vous permet de créer des lots applicatifs qui peuvent facilement être distribués à des utilisateurs qui n’utilisent pas Guix.


Suivant: , Monter: Développement   [Table des matières][Index]

7.1 Invoquer guix environment

Le but de guix environment est d’assister les hackers dans la création d’environnements de développement reproductibles sans polluer leur profil de paquets. L’outil guix environment prend un ou plusieurs paquets, construit leurs entrées et crée un environnement shell pour pouvoir les utiliser.

La syntaxe générale est :

guix environment options paquet

L’exemple suivant crée un nouveau shell préparé pour le développement de GNU Guile :

guix environment guile

Si les dépendances requises ne sont pas déjà construites, guix environment les construit automatiquement. L’environnement du nouveau shell est une version améliorée de l’environnement dans lequel guix environment a été lancé. Il contient les chemins de recherche nécessaires à la construction du paquet donné en plus des variables d’environnement existantes. Pour créer un environnement « pur », dans lequel les variables d’environnement de départ ont été nettoyées, utilisez l’option --pure11.

Exiting from a Guix environment is the same as exiting from the shell, and will place the user back in the old environment before guix environment was invoked. The next garbage collection (voir Invoquer guix gc) will clean up packages that were installed from within the environment and are no longer used outside of it.

guix environment définie la variable GUIX_ENVIRONMENT dans le shell qu’il crée ; sa valeur est le nom de fichier du profil de cet environnement. Cela permet aux utilisatrice·eur·s, disons, de définir un prompt spécifique pour les environnement de développement dans leur .bashrc (voir Bash Startup Files dans The GNU Bash Reference Manual) :

if [ -n "$GUIX_ENVIRONMENT" ]
then
    export PS1="\u@\h \w [dev]\$ "
fi

… ou de naviguer dans le profil :

$ ls "$GUIX_ENVIRONMENT/bin"

De surcroît, plus d’un paquet peut être spécifié, auquel cas l’union des entrées des paquets données est utilisée. Par exemple, la commande ci-dessous crée un shell où toutes les dépendances de Guile et Emacs sont disponibles :

guix environment guile emacs

Parfois, une session shell interactive est inutile. On peut invoquer une commande arbitraire en plaçant le jeton -- pour séparer la commande du reste des arguments :

guix environment guile -- make -j4

Dans d’autres situations, il est plus pratique de spécifier la liste des paquets requis dans l’environnement. Par exemple, la commande suivante lance python dans un environnement contenant Python 2.7 et NumPy :

guix environment --ad-hoc python2-numpy python-2.7 -- python

En plus, on peut vouloir les dépendance d’un paquet et aussi des paquets supplémentaires qui ne sont pas des dépendances à l’exécution ou à la construction, mais qui sont utiles au développement tout de même. À cause de cela, le tag --ad-hoc est positionnel. Les paquets qui apparaissent avant --ad-hoc sont interprétés comme les paquets dont les dépendances seront ajoutées à l’environnement. Les paquets qui apparaissent après --ad-hoc sont interprétés comme les paquets à ajouter à l’environnement directement. Par exemple, la commande suivante crée un environnement de développement pour Guix avec les paquets Git et strace en plus :

guix environment --pure guix --ad-hoc git strace

Parfois il est souhaitable d’isoler l’environnement le plus possible, pour une pureté et une reproductibilité maximale. En particulier, lorsque vous utilisez Guix sur une distribution hôte qui n’est pas le système Guix, il est souhaitable d’éviter l’accès à /usr/bin et d’autres ressources du système depuis les environnements de développement. Par exemple, la commande suivante crée un REPL Guile dans un « conteneur » où seuls le dépôt et le répertoire de travail actuel sont montés :

guix environment --ad-hoc --container guile -- guile

Remarque : L’option --container requiert Linux-libre 3.19 ou supérieur.

Un autre cas d’usage typique pour les conteneurs est de lancer des applications sensibles à la sécurité, comme un navigateur web. Pour faire fonctionner Eolie, nous devons exposer et partager certains fichiers et répertoires ; nous incluons nss-certs et exposons /etc/ssl/certs/ pour l’authentification HTTPS ; enfin, nous préservons la variable d’environnement DISPLAY puisque les applications graphiques conteneurisées ne s’afficheront pas sans elle.

guix environment --preserve='^DISPLAY$' --container --network \
  --expose=/etc/machine-id \
  --expose=/etc/ssl/certs/ \
  --share=$HOME/.local/share/eolie/=$HOME/.local/share/eolie/ \
  --ad-hoc eolie nss-certs dbus --  eolie

Les options disponibles sont résumées ci-dessous.

--root=fichier
-r fichier

Fait de fichier un lien symbolique vers le profil de cet environnement, et l’enregistre comme une racine du ramasse-miettes.

C’est utile si vous souhaitez protéger votre environnement du ramasse-miettes, pour le rendre « persistent ».

Lorsque cette option est omise, l’environnement n’est protégé du ramasse-miettes que le temps de la session guix environment. Cela signifie que la prochaine fois que vous créerez le même environnement, vous pourriez avoir à reconstruire ou télécharger des paquets. Voir Invoquer guix gc, pour plus d’informations sur les racines du GC.

--expression=expr
-e expr

Crée un environnement pour le paquet ou la liste de paquets en lesquels s’évalue expr.

Par exemple, lancer :

guix environment -e '(@ (gnu packages maths) petsc-openmpi)'

démarre un shell avec l’environnement pour cette variante spécifique du paquet PETSc.

Lancer :

guix environment --ad-hoc -e '(@ (gnu) %base-packages)'

démarre un shell où tous les paquets de base du système sont disponibles.

Les commande au-dessus n’utilisent que les sorties par défaut des paquets donnés. Pour choisir d’autres sorties, on peut spécifier des pairs :

guix environment --ad-hoc -e '(list (@ (gnu packages bash) bash) "include")'
--load=fichier
-l fichier

Crée un environnement pour le paquet ou la liste de paquets en lesquels fichier s’évalue.

Par exemple, fichier peut contenir une définition comme celle-ci (voir Définition des paquets) :

(use-modules (guix)
             (gnu packages gdb)
             (gnu packages autotools)
             (gnu packages texinfo))

;; Augment the package definition of GDB with the build tools
;; needed when developing GDB (and which are not needed when
;; simply installing it.)
(package (inherit gdb)
  (native-inputs `(("autoconf" ,autoconf-2.64)
                   ("automake" ,automake)
                   ("texinfo" ,texinfo)
                   ,@(package-native-inputs gdb))))
--manifest=fichier
-m fichier

Crée un environnement pour les paquets contenus dans l’objet manifeste renvoyé par le code Scheme dans fichier. Vous pouvez répéter cette option plusieurs fois, auquel cas les manifestes sont concaténés.

C’est similaire à l’option de même nom de guix package (voir --manifest) et utilise les même fichiers manifestes.

--ad-hoc

Inclut tous les paquets spécifiés dans l’environnement qui en résulte, comme si un paquet ad hoc était spécifié, avec ces paquets comme entrées. Cette option est utile pour créer un environnement rapidement sans avoir à écrire une expression de paquet contenant les entrées désirées.

Par exemple la commande :

guix environment --ad-hoc guile guile-sdl -- guile

lance guile dans un environnement où Guile et Guile-SDDL sont disponibles.

Remarquez que cet exemple demande implicitement la sortie par défaut de guile et guile-sdl, mais il est possible de demander une sortie spécifique — p. ex. glib:bin demande la sortie bin de glib (voir Des paquets avec plusieurs résultats).

Cette option peut être composée avec le comportement par défaut de guix environment. Les paquets qui apparaissent avant --ad-hoc sont interprétés comme les paquets dont les dépendances seront ajoutées à l’environnement, le comportement par défaut. Les paquets qui apparaissent après --ad-hoc sont interprétés comme les paquets à ajouter à l’environnement directement.

--pure

Réinitialisation des variables d’environnement existantes lors de la construction du nouvel environnement, sauf celles spécifiées avec l’option --preserve. (voir ci-dessous). Cela a pour effet de créer un environnement dans lequel les chemins de recherche ne contiennent que des entrées de paquets.

--preserve=regexp
-E regexp

Lorsque vous utilisez --pure, préserver les variables d’environnement qui correspondent à regexp — en d’autres termes, cela les met en « liste blanche » de variables d’environnement qui doivent être préservées. Cette option peut être répétée plusieurs fois.

guix environment --pure --preserve=^SLURM --ad-hoc openmpi … \
  -- mpirun …

Cet exemple exécute mpirun dans un contexte où les seules variables d’environnement définies sont PATH, les variables d’environnement dont le nom commence par ‘SLURM’, ainsi que les variables « importantes » habituelles (HOME, USER, etc.).

--search-paths

Affiche les définitions des variables d’environnement qui composent l’environnement.

--system=système
-s système

Essaye de construire pour système — p. ex. i686-linux.

--container
-C

Lance commande dans un conteneur isolé. Le répertoire de travail actuel en dehors du conteneur est monté dans le conteneur. En plus, à moins de le changer avec --user, un répertoire personnel fictif est créé pour correspondre à celui de l’utilisateur·rice actuel·le et /etc/passwd est configuré en conséquence.

Le processus de création s’exécute en tant qu’utilisateur·rice actuel·le à l’extérieur du conteneur. À l’intérieur du conteneur, il possède les mêmes UID et GID que l’utilisateur·rice actuel·le, sauf si l’option --user est passée (voir ci-dessous).

--network
-N

Pour les conteneurs, partage l’espace de nom du réseau avec le système hôte. Les conteneurs créés sans cette option n’ont accès qu’à l’interface de boucle locale.

--link-profile
-P

Pour les conteneurs, liez le profil d’environnement à ~/.guix-profile à l’intérieur du conteneur et définissez GUIX_ENVIRONNEMENT à cet endroit. Cela équivaut à faire de ~/.guix-profile un lien symbolique vers le profil réel à l’intérieur du conteneur. La liaison échouera et interrompra l’environnement si le répertoire existe déjà, ce qui sera certainement le cas si guix environment a été invoqué dans le répertoire personnel de l’utilisateur·rice.

Certains paquets sont configurés pour chercher des fichiers de configuration et des données dans ~/.guix-profile ; 12 ; --link-profile permet à ces programmes de se comporter comme attendu dans l’environnement.

--user=utilisateur
-u utilisateur

Pour les conteneurs, utilise le nom d’utilisateur utilisateur à la place de l’utilisateur actuel. L’entrée générée dans /etc/passwd dans le conteneur contiendra le nom utilisateur ; le répertoire personnel sera /home/utilisateur ; et aucune donnée GECOS ne sera copiée. En plus, l’UID et le GID dans le conteneur seront 1000. user n’a pas besoin d’exister sur le système.

En plus, tous les chemins partagés ou exposés (voir --share et --expose respectivement) dont la cible est dans le répertoire personnel de l’utilisateur·rice seront remontés relativement à /home/USER ; cela comprend le montage automatique du répertoire de travail actuel.

# exposera les chemins comme /home/foo/wd, /home/foo/test et /home/foo/target
cd $HOME/wd
guix environment --container --user=foo \
     --expose=$HOME/test \
     --expose=/tmp/target=$HOME/target

Bien que cela limite la fuite de l’identité de l’utilisateur à travers le chemin du répertoire personnel et des champs de l’utilisateur, ce n’est qu’un composant utile pour une solution d’anonymisation ou de préservation de la vie privée — pas une solution en elle-même.

--no-cwd

Pour les conteneurs, le comportement par défaut est de partager le répertoire de travail actuel avec le conteneur isolé et de passer immédiatement à ce répertoire à l’intérieur du conteneur. Si cela n’est pas souhaitable, --no-cwd fera en sorte que le répertoire de travail courant soit automatiquement partagé not et passera au répertoire personnel de l’utilisateur·rice dans le conteneur à la place. Voir aussi --user.

--expose=source[=cible]
--share=source[=cible]

Pour les conteneurs, --expose (resp. --share) expose le système de fichiers source du système hôte comme un système de fichiers target en lecture seule (resp. en lecture-écriture) dans le conteneur. Si target n’est pas spécifiée, source est utilisé comme point de montage dans le conteneur.

L’exemple ci-dessous crée un REPL Guile dans un conteneur dans lequel le répertoire personnel de l’utilisateur est accessible en lecture-seule via le répertoire /exchange :

guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile

En plus, guix environment prend en charge toutes les options de construction communes prises en charge par guix build (voir Options de construction communes) et toutes les options de transformation de paquets (voir Options de transformation de paquets).


Suivant: , Précédent: , Monter: Développement   [Table des matières][Index]

7.2 Invoquer guix pack

Parfois vous voulez passer un logiciel à des gens qui n’ont pas (encore !) la chance d’utiliser Guix. Vous leur diriez bien de lancer guix package -i quelque chose mais ce n’est pas possible dans ce cas. C’est là que guix pack entre en jeu.

Remarque : Si vous cherchez comment échanger des binaires entre des machines où Guix est déjà installé, voir Invoquer guix copy, Invoquer guix publish, et Invoquer guix archive.

La commande guix pack crée un pack ou lot de logiciels : elle crée une archive tar ou un autre type d’archive contenant les binaires pour le logiciel qui vous intéresse ainsi que ses dépendances. L’archive qui en résulte peut être utilisée sur toutes les machines qui n’ont pas Guix et les gens peuvent lancer exactement les mêmes binaires que ceux que vous avez avec Guix. Le pack lui-même est créé d’une manière reproductible au bit près, pour que n’importe qui puisse vérifier qu’il contient bien les résultats que vous prétendez proposer.

Par exemple, pour créer un lot contenant Guile, Emacs, Geiser et toutes leurs dépendances, vous pouvez lancer :

$ guix pack guile emacs geiser
…
/gnu/store/…-pack.tar.gz

Le résultat ici est une archive tar contenant un répertoire /gnu/store avec tous les paquets nécessaires. L’archive qui en résulte contient un profil avec les trois paquets qui vous intéressent ; le profil est le même qui celui qui aurait été créé avec guix package -i. C’est ce mécanisme qui est utilisé pour créer les archives tar binaires indépendantes de Guix (voir Installation binaire).

Les utilisateurs de ce pack devraient lancer /gnu/store/…-profile/bin/guile pour lancer Guile, ce qui n’est pas très pratique. Pour éviter cela, vous pouvez créer, disons, un lien symbolique /opt/gnu/bin vers le profil :

guix pack -S /opt/gnu/bin=bin guile emacs geiser

De cette façon, les utilisateurs peuvent joyeusement taper /opt/gnu/bin/guile et profiter.

Et si le destinataire de votre pack n’a pas les privilèges root sur sa machine, et ne peut donc pas le décompresser dans le système de fichiers root ? Dans ce cas, vous pourriez utiliser l’option --relocatable (voir plus bas). Cette option produit des binaires repositionnables, ce qui signifie qu’ils peuvent être placés n’importe où dans l’arborescence du système de fichiers : dans l’exemple au-dessus, les utilisateur·rice·s peuvent décompresser votre archive dans leur répertoire personnel et lancer directement ./opt/gnu/bin/guile.

Autrement, vous pouvez produire un pack au format d’image Docker avec la commande suivante :

guix pack -f docker -S /bin=bin guile guile-readline

Le résultat est une archive tar qui peut être passée à la commande docker load, puis à docker run :

docker load < file
docker run -ti guile-guile-readline /bin/guile

fichier est l’image renvoyée par guix pack et guile-guile-readline est son « tag d’image ». Voir la documentation de Docker pour plus d’informations.

Autrement, vous pouvez produire une image SquashFS avec la commande suivante :

guix pack -f squashfs bash guile emacs geiser

Le résultat est une image de système de fichiers SquashFS qui peut soit être montée directement soit être utilisée comme image de conteneur de système de fichiers avec l’Singularity container execution environment, avec des commandes comme singularity shell ou singularity exec.

Diverses options en ligne de commande vous permettent de personnaliser votre pack :

--format=format
-f format

Produire un pack dans le format donné.

Les formats disponibles sont :

tarball

C’est le format par défaut. Il produit une archive tar contenant tous les binaires et les liens symboliques spécifiés.

docker

Cela produit une archive tar qui suit la spécification des images Docker. Le « nom de dépôt » qui apparaît dans la sortie de la command docker images est calculé à partir des noms des paquets passés sur la ligne de commande ou dans le fichier manifeste.

squashfs

Cela produit une image SquashFS contenant tous les binaires et liens symboliques spécifiés, ainsi que des points de montages vides pour les systèmes de fichiers virtuels comme procfs.

Remarque : Singularity requiert que vous fournissiez /bin/sh dans l’image. Pour cette raison, guix pack -f squashfs implique toujours -S /bin=bin. Ainsi, votre invocation guix pack doit toujours commencer par quelque chose comme :

guix pack -f squashfs bash …

Si vous oubliez le paquet bash (ou similaire), singularity run et singularity exec vont échouer avec un message « no such file or directory » peu utile.

--relocatable
-R

Produire des binaires repositionnables — c.-à-d. des binaires que vous pouvez placer n’importe où dans l’arborescence du système de fichiers et les lancer à partir de là.

Lorsque vous passez cette option une fois, les binaires qui en résultent demandent le support des espaces de nom utilisateurs dans le noyau Linux ; lorsque vous la passez deux fois13, les binaires repositionnables utilisent PRoot si les espaces de noms ne sont pas utilisables, et ça fonctionne à peu près partout — voir plus bas pour comprendre les implications.

Par exemple, si vous créez un pack contenant Bash avec :

guix pack -RR -S /mybin=bin bash

… vous pouvez copier ce pack sur une machine qui n’a pas Guix et depuis votre répertoire personnel en tant qu’utilisateur non-privilégié, lancer :

tar xf pack.tar.gz
./mybin/sh

Dans ce shell, si vous tapez ls /gnu/store, vous remarquerez que /gnu/store apparaît et contient toutes les dépendances de bash, même si la machine n’a pas du tout de /gnu/store ! C’est sans doute la manière la plus simple de déployer du logiciel construit avec Guix sur une machine sans Guix.

Remarque : Par défaut ,les binaires repositionnables s’appuient sur les espaces de noms utilisateurs du noyau Linux, qui permet à des utilisateurs non-privilégiés d’effectuer des montages et de changer de racine. Les anciennes versions de Linux ne le supportait pas et certaines distributions GNU/Linux le désactive.

Pour produire des binaires repositionnables qui fonctionnent même sans espace de nom utilisatrice·eur, passez --relocatable ou -R deux fois. Dans ce cas, les binaires testeront la prise en charge des espaces de noms utilisatrice·eur·s et utiliseront PRoot s’ils ne sont pas pris en charge. Les moteurs d’exécution suivants sont pris en charge :

default

Essayez les espaces de noms utilisateur·rice·s et revenez à PRoot si les espaces de noms utilisateur·rice·s ne sont pas pris en charge (voir ci-dessous).

performance

Essayez les espaces de noms utilisateur·rice·s et revenez à Fakechroot si les espaces de noms utilisateur·rice·s ne sont pas pris en charge (voir ci-dessous).

users

Lance le programme à travers les espaces de nom utilisateur·rice et échoue s’ils ne sont pas supportés.

proot

Passez à travers PRoot. Le programme PRoot fournit la prise en charge nécessaire pour la virtualisation du système de fichier. Il y parvient en utilisant l’appel système ptrace sur le programme courant. Cette approche a l’avantage de fonctionner sans demander de support spécial de la part du noyau, mais occasionne un coût supplémentaire en temps pour chaque appel système effectué.

fakechroot

Passez à travers Fakechroot. Fakechroot virtualise les accès au système de fichier en interceptant les appels vers les fonctions de la bibliothèque C telles que open, stat, exec, et ainsi de suite. Contrairement à PRoot, il n’engendre que très peu de coûts généraux. Cependant, il ne fonctionne pas encore tout-à-fait : par exemple, certains accès au système de fichier effectués à partir de la bibliothèque C ne sont pas interceptés, et les accès au système de fichier effectués via les appels système directs ne sont pas non plus interceptés, conduisant à un comportement erratique.

Lors de l’exécution d’un programme complet, vous pouvez demander explicitement l’un des moteurs d’exécution énumérés ci-dessus en définissant en conséquence la variable d’environnement GUIX_EXECUTION_ENGINE.

--entry-point=commande

Utiliser commande comme point d’entrée du paquet résultant, si le format du paquet le supporte–actuellement docker et squashfs (Singularity) la supportent. command doit être relatif au profil contenu dans le pack.

Le point d’entrée spécifie la commande que des outils comme docker run or singularity run lancent automatiquement par défaut. Par exemple, vous pouvez faire :

guix pack -f docker --entry-point=bin/guile guile

Le pack résultant peut être facilement chargé et docker run sans arguments supplémentaires engendrera bin/guile :

docker load -i pack.tar.gz
docker run image-id
--expression=expr
-e expr

Considérer le paquet évalué par expr.

Cela a le but identique que l’option de même nom de guix build (voir --expression dans guix build).

--manifest=fichier
-m fichier

Utiliser les paquets contenus dans l’objet manifeste renvoyé par le code Scheme dans fichier. Vous pouvez répéter cette option plusieurs fois, auquel cas les manifestes sont concaténés.

Elle a un but similaire à l’option de même nom dans guix package (voir --manifest) et utilise les mêmes fichiers manifeste. Ils vous permettent de définir une collection de paquets une fois et de l’utiliser aussi bien pour créer des profils que pour créer des archives pour des machines qui n’ont pas Guix d’installé. Remarquez que vous pouvez spécifier soit un fichier manifeste, soit une liste de paquet, mais pas les deux.

--system=système
-s système

Tenter de construire pour le système — p. ex. i686-linux — plutôt que pour le type de système de l’hôte de construction.

--target=triplet

Effectuer une compilation croisée pour triplet qui doit être un triplet GNU valide, comme ""aarch64-linux-gnu"" (voir GNU configuration triplets dans Autoconf).

--compression=outil
-C outil

Compresser l’archive résultante avec outil — l’un des outils parmi gzip, zstd, bzip2, xz, lzip, ou none pour aucune compression.

--symlink=spec
-S spec

Ajouter les liens symboliques spécifiés par spec dans le pack. Cette option peut apparaître plusieurs fois.

spec a la forme source=cible, où source est le lien symbolique qui sera créé et cible est la cible du lien.

Par exemple, -S /opt/gnu/bin=bin crée un lien symbolique /opt/gnu/bin qui pointe vers le sous-répertoire bin du profil.

--save-provenance

Sauvegarder les informations de provenance des paquets passés sur la ligne de commande. Les informations de provenance contiennent l’URL et le commit des canaux utilisés (voir Canaux).

Les informations de provenance sont sauvegardées dans le fichier /gnu/store/…-profile/manifest du pack, avec les métadonnées de paquets habituelles — le nom et la version de chaque paquet, leurs entrées propagées, etc. Ce sont des informations utiles pour le destinataire du pack, qui sait alors comment le pack a (normalement) été obtenu.

Cette option n’est pas activée par défaut car, comme l’horodatage, les informations de provenance ne contribuent en rien au processus de construction. En d’autres termes, il y a une infinité d’URL et d’ID de commit qui permettent d’obtenir le même pack. Enregistrer de telles métadonnées « silencieuses » dans la sortie casse donc éventuellement la propriété de reproductibilité au bit près.

--root=fichier
-r fichier

Fait de fichier un lien symbolique vers le résultat, et l’enregistre en tant que racine du ramasse-miettes.

--localstatedir
--profile-name=nom

Inclus le « répertoire d’état local », /var/guix, dans le lot qui en résulte, et notamment le profil /var/guix/profiles/per-user/root/nom — par défaut nom est guix-profile, ce qui correspond à ~root/.guix-profile.

/var/guix contient la base de données du dépôt (voir Le dépôt) ainsi que les racines du ramasse-miettes (voir Invoquer guix gc). Le fournir dans le pack signifie que le dépôt et « complet » et gérable par Guix ; ne pas le fournir dans le pack signifie que le dépôt est « mort » : aucun élément ne peut être ajouté ni enlevé après l’extraction du pack.

Un cas d’utilisation est l’archive binaire indépendante de Guix (voir Installation binaire).

--derivation
-d

Affiche le nom de la dérivation que le pack construit.

--bootstrap

Utiliser les programmes d’amorçage pour construire le pack. Cette option n’est utile que pour les personnes qui développent Guix.

En plus, guix pack supporte toutes les options de construction communes (voir Options de construction communes) et toutes les options de transformation de paquets (voir Options de transformation de paquets).


Suivant: , Précédent: , Monter: Développement   [Table des matières][Index]

7.3 La chaîne d’outils GCC

Guix offre des paquets de compilateurs individuels comme gcc mais si vous avez besoin d’une chaîne de compilation complète pour compiler et lier du code source, utilisez le paquet gcc-toolchain. Ce paquet fournit une chaîne d’outils complète GCC pour le développement C/C++, dont GCC lui-même, la bibliothèque C de GNU (les en-têtes et les binaires, plus les symboles de débogage dans la sortie debug), Binutils et un wrapper pour l’éditeur de liens.

Le rôle de l’enveloppe est d’inspecter les paramètres -L et -l passés à l’éditeur de liens, d’ajouter des arguments -rpath correspondants et d’invoquer l’actuel éditeur de liens avec ce nouvel ensemble d’arguments. Vous pouvez dire au wrapper de refuser de lier les programmes à des bibliothèques en dehors du dépôt en paramétrant la variable d’environnement GUIX_LD_WRAPPER_ALLOW_IMPURITIES sur no.

Le paquet gfortran-toolchain fournit une chaîne d’outils GCC complète pour le développement en Fortran. Pour d’autres langages, veuillez utiliser ‘guix search gcc toolchain’ (voir Invoquer guix package).


Précédent: , Monter: Développement   [Table des matières][Index]

7.4 Invoquer guix git authenticate

La commande guix git authenticate authentifie un checkout Git en suivant la même règle que pour les canaux (voir channel authentication). C’est-à-dire qu’à partir d’un commit donné, il s’assure que tous les commit suivants sont signés par une clé OpenPGP dont l’empreinte digitale apparaît dans le fichier .guix-authorizations de son ou ses commit(s) parent(s).

Vous allez trouver cette commande utile si vous maintenez un canal. Mais en fait, ce mécanisme d’authentification est utile dans un contexte plus large, Vous pourriez donc vouloir l’utiliser pour des dépôts Git qui n’ont rien à voir avec Guix.

La syntaxe générale est :

guix git authenticate commit signer [options…]

Par défaut, cette commande authentifie le chekout Git dans le répertoire courant ; il ne produit rien et sort avec le code de sortie zéro en cas de succès et non zéro en cas d’échec. commit ci-dessus désigne le premier commit où l’authentification a lieu, et signer est l’empreinte OpenPGP de la clé publique utilisée pour signer commit. Ensemble, ils forment une «introduction de canal» (voir introduction de canal). Les options ci-dessous vous permettent d’affiner le processus.

--repository=répertoire
-r répertoire

Ouvre le dépôt Git dans directory au lieu du répertoire courant.

--keyring=référence
-k féférence

Chargez le porte-clés OpenPGP à partir de référence, la référence d’une branche telle que origin/keyring ou my-keyring. La branche doit contenir des clés publiques OpenPGP dans des fichiers .key, soit sous forme binaire, soit "blindée ASCII". Par défaut, le porte-clés est chargé à partir de la branche nommée keyring.

--stats

Affiche les statistiques sur les signatures de commits à l’issue de la procédure.

--cache-key=key

Les commits préalablement authentifiés sont mis en cache dans un fichier sous ~/.cache/guix/authentication. Cette option force le cache à être stocké dans le fichier key de ce répertoire.

--historical-authorizations=fichier

Par défaut, tout commit dont le(s) commit(s) parent(s) ne contient(nt) pas le fichier .guix-authorizations est considéré comme non authentique. En revanche, cette option considère les autorisations dans file pour tout commit dont le fichier .guix-authorizations est manquant. Le format de file est le même que celui de .guix-authorizations (au format voir .guix-autorizations).


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

8 Interface de programmation

GNU Guix fournit diverses interface de programmation Scheme (API) qui pour définir, construire et faire des requêtes sur des paquets. La première interface permet aux utilisateurs d’écrire des définitions de paquets de haut-niveau. Ces définitions se réfèrent à des concepts de création de paquets familiers, comme le nom et la version du paquet, son système de construction et ses dépendances. Ces définitions peuvent ensuite être transformées en actions concrètes lors de la construction.

Les actions de construction sont effectuées par le démon Guix, pour le compte des utilisateur·rice·s. Dans un environnement standard, le démon possède les droits en écriture sur le dépôt — le répertoire /gnu/store — mais pas les utilisateur·rice·s. La configuration recommandée permet aussi au démon d’effectuer la construction dans des chroots, à l’adresse des utilisateur·rice·s de construction spécifiques, pour minimiser les interférences avec le reste du système.

Il y a des API de plus bas niveau pour interagir avec le démon et le dépôt. Pour demander au démon d’effectuer une action de construction, les utilisateurs lui donnent en fait une dérivation. Une dérivation est une représentation à bas-niveau des actions de construction à entreprendre et l’environnement dans lequel elles devraient avoir lieu — les dérivations sont aux définitions de paquets ce que l’assembleur est aux programmes C. Le terme de « dérivation » vient du fait que les résultats de la construction en dérivent.

Ce chapitre décrit toutes ces API tour à tour, à partir des définitions de paquets à haut-niveau.


Suivant: , Monter: Interface de programmation   [Table des matières][Index]

8.1 Modules de paquets

D’un point de vue programmatique, les définitions de paquets de la distribution GNU sont fournies par des modules Guile dans l’espace de noms (gnu packages …)14 (voir Guile modules dans GNU Guile Reference Manual). Par exemple, le module (gnu packages emacs) exporte une variable nommée emacs, qui est liée à un objet <package> (voir Définition des paquets).

L’espace de nom (gnu packages …) est automatiquement scanné par les outils en ligne de commande. Par exemple, lorsque vous lancez guix install emacs, tous les modules (gnu packages …) sont scannés jusqu’à en trouver un qui exporte un objet de paquet dont le nom est emacs. Cette capacité à chercher des paquets est implémentée dans le module (gnu packages).

Les utilisateur·rice·s peuvent stocker les définitions de paquets dans des modules ayant des noms différents—par exemple, (my-packages emacs)15. Il y a deux façons de rendre ces définitions de paquets visibles pour les interfaces utilisateur·rice :

  1. En ajoutant le répertoire contenant vos modules de paquets au chemin de recherche avec le tag -L de guix package et des autres commandes (voir Options de construction communes) ou en indiquant la variable d’environnement GUIX_PACKAGE_PATH décrite plus bas.
  2. En définissant un canal et en configurant guix pull pour qu’il l’utilise. Un canal est en substance un dépôt Git contenant des modules de paquets. Voir Canaux, pour plus d’informations sur comment définir et utiliser des canaux.

GUIX_PACKAGE_PATH fonctionne comme les autres variables de chemins de recherche :

Variable d'environnement : GUIX_PACKAGE_PATH

C’est une liste séparée par des deux-points de répertoires dans lesquels trouver des modules de paquets supplémentaires. Les répertoires listés dans cette variable sont prioritaires par rapport aux paquets de la distribution.

La distribution est entièrement bootstrappée et auto-contenue : chaque paquet est construit uniquement à partir d’autres paquets de la distribution. La racine de ce graphe de dépendance est un petit ensemble de binaires de bootstrap fournis par le module (gnu packages bootstrap). Pour plus d’informations sur le bootstrap, voir Bootstrapping.


Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.2 Définition des paquets

L’interface de haut-niveau pour les définitions de paquets est implémentée dans les modules (guix packages) et (guix build-system). Par exemple, la définition du paquet, ou la recette, du paquet GNU Hello ressemble à cela :

(define-module (gnu packages hello)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix build-system gnu)
  #:use-module (guix licenses)
  #:use-module (gnu packages gawk))

(define-public hello
  (package
    (name "hello")
    (version "2.10")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-" version
                                  ".tar.gz"))
              (sha256
               (base32
                "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
    (build-system gnu-build-system)
    (arguments '(#:configure-flags '("--enable-silent-rules")))
    (inputs `(("gawk" ,gawk)))
    (synopsis "Hello, GNU world: An example GNU package")
    (description "Guess what GNU Hello prints!")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))

Sans être un expert Scheme, le lecteur peut comprendre la signification des différents champs présents. Cette expression lie la variable hello à un objet <package>, qui est en substance un enregistrement (voir Scheme records dans GNU Guile Reference Manual). On peut inspecter cet objet de paquet avec les procédures qui se trouvent dans le module (guix packages) ; par exemple, (package-name hello) renvoie — oh surprise ! — "hello".

Avec un peu de chance, vous pourrez importer tout ou partie de la définition du paquet qui vous intéresse depuis un autre répertoire avec la commande guix import (voir Invoquer guix import).

Dans l’exemple précédent, hello est défini dans un module à part, (gnu packages hello). Techniquement, cela n’est pas strictement nécessaire, mais c’est pratique : tous les paquets définis dans des modules sous (gnu packages …) sont automatiquement connus des outils en ligne de commande (voir Modules de paquets).

Il y a quelques points à remarquer dans la définition de paquet précédente :

Voir référence des paquets, pour une description complète des champs possibles.

Lorsqu’une définition de paquet est en place, le paquet peut enfin être construit avec l’outil en ligne de commande guix build (voir Invoquer guix build), pour résoudre les échecs de construction que vous pourriez rencontrer (voir Débogage des échecs de construction). Vous pouvez aisément revenir à la définition du paquet avec la commande guix edit (voir Invoquer guix edit). Voir Consignes d'empaquetage, pour plus d’informations sur la manière de tester des définitions de paquets et Invoquer guix lint, pour des informations sur la manière de vérifier que la définition respecte les conventions de style. Enfin, voir Canaux pour des informations sur la manière d’étendre la distribution en ajoutant vos propres définitions de paquets dans un « canal ».

Finalement, la mise à jour de la définition du paquet à une nouvelle version amont peut en partie s’automatiser avec la commande guix refresh (voir Invoquer guix refresh).

Sous le capot, une dérivation qui correspond à un objet <package> est d’abord calculé par la procédure package-derivation. Cette dérivation est stockée dans un fichier .drv dans /gnu/store. Les actions de construction qu’il prescrit peuvent ensuite être réalisées par la procédure build-derivation (voir Le dépôt).

Procédure Scheme : package-derivation store package [system]

Renvoie l’objet <derivation> du paquet pour le système (voir Dérivations).

paquet doit être un objet <package> valide et système une chaîne indiquant le type de système cible — p.ex. "x86_64-linux" pour un système GNU x86_64 basé sur Linux. dépôt doit être une connexion au démon, qui opère sur les dépôt (voir Le dépôt).

De manière identique, il est possible de calculer une dérivation qui effectue une compilation croisée d’un paquet pour un autre système :

Procédure Scheme : package-cross-derivation store paquet cible [système] renvoie l'objet <derivation>

du paquet construit depuis système pour cible.

cible doit être un triplet GNU valide indiquant le matériel cible et le système d’exploitation, comme "aarch64-linux-gnu" (voir Specifying Target Triplets dans Autoconf).

Une fois qu’on a une définition de paquet, on peut facilement définir des variantes du paquet. Voir Définition de variantes de paquets, pour plus d’informations.


Suivant: , Monter: Définition des paquets   [Table des matières][Index]

8.2.1 Référence de package

Cette section résume toutes les options disponibles dans les déclarations package (voir Définition des paquets).

Type de données : package

C’est le type de donnée représentant une recette de paquets.

name

Le nom du paquet, comme une chaîne de caractères.

version

La version du paquet, comme une chaîne de caractères.

source

Un objet qui indique comment le code source du paquet devrait être récupéré. La plupart du temps, c’est un objet origin qui indique un fichier récupéré depuis internet (voir référence des origines). Il peut aussi s’agir de tout autre objet « simili-fichier » comme un local-file qui indique un fichier du système de fichier local (voir local-file).

build-system

Le système de construction qui devrait être utilisé pour construire le paquet (voir Systèmes de construction).

arguments (par défaut : '())

Les arguments à passer au système de construction. C’est une liste qui contient typiquement une séquence de paires de clefs-valeurs.

inputs (par défaut : '())
native-inputs (par défaut : '())
propagated-inputs (par défaut : '())

Ces champs listent les dépendances du paquet. Chacune est une liste de tuples, où chaque tuple a une étiquette pour une entrée (une chaîne de caractères) comme premier élément, un paquet, une origine ou une dérivation comme deuxième élément et éventuellement le nom d’une sortie à utiliser qui est "out" par défaut (voir Des paquets avec plusieurs résultats, pour plus d’informations sur les sorties des paquets). Par exemple, la liste suivante spécifie trois entrées :

`(("libffi" ,libffi)
  ("libunistring" ,libunistring)
  ("glib:bin" ,glib "bin"))  ;la sortie "bin" de Glib

La distinction entre native-inputs et inputs est nécessaire lorsqu’on considère la compilation croisée. Lors d’une compilation croisée, les dépendances listées dans inputs sont construites pour l’architecture cible ; inversement, les dépendances listées dans native-inputs sont construites pour l’architecture de la machine de construction.

native-inputs est typiquement utilisé pour lister les outils requis à la construction mais pas à l’exécution, comme Autoconf, Automake, pkg-config, Gettext ou Bison. guix lint peut rapporter des erreurs de ce type (voir Invoquer guix lint).

Enfin, propagated-inputs est similaire à inputs, mais les paquets spécifiés seront automatiquement installés sur les profils (voir le rôle des profils dans Guix) à côté du paquet auquel ils appartiennent (voir guix package, pour savoir comment guix package traite les entrées propagées).

Par exemple, cela est nécessaire lors de l’empaquetage d’une bibliothèque C/C++ qui a besoin des en-têtes d’une autre bibliothèque pour se compiler, ou lorsqu’un fichier pkg-config fait référence à un autre via son champ Requires.

Un autre exemple où le propagated-inputs est utile, c’est pour les langues qui ne disposent pas de la possibilité d’enregistrer le chemin de recherche à l’exécution comme le RUNPATH des fichiers ELF ; cela inclut Guile, Python, Perl, et plus encore. Lors de l’empaquetage de bibliothèques écrites dans ces langages, assurez-vous qu’elles peuvent trouver le code de bibliothèque dont elles dépendent au moment de l’exécution en listant les dépendances d’exécution dans propagated-inputs plutôt que inputs.

outputs (par défaut : '("out"))

La liste des noms de sorties du paquet. Voir Des paquets avec plusieurs résultats, pour des exemples typiques d’utilisation de sorties supplémentaires.

native-search-paths (par défaut : '())
search-paths (par défaut : '())

Une liste d’objets search-path-specification décrivant les variables d’environnement de recherche de chemins que ce paquet utilise.

replacement (par défaut : #f)

Ce champ doit être soit #f soit un objet de paquet qui sera utilisé comme remplaçant de ce paquet. Voir grafts, pour plus de détails.

synopsis

Une description sur une ligne du paquet.

description

Une description plus détaillée du paquet.

license

La licence du paquet ; une valeur tirée de (guix licenses) ou une liste de ces valeurs.

home-page

L’URL de la page d’accueil du paquet, en tant que chaîne de caractères.

supported-systems (par défaut : %supported-systems)

La liste des systèmes supportés par le paquet, comme des chaînes de caractères de la forme architecture-noyau, par exemple "x86_64-linux".

location (par défaut : emplacement de la source de la forme package)

L’emplacement de la source du paquet. C’est utile de le remplacer lorsqu’on hérite d’un autre paquet, auquel cas ce champ n’est pas automatiquement corrigé.

Syntaxe Scheme : this-package

Lorsque vous l’utilisez dans la portée lexicale du champ d’une définition de paquet, cet identifiant est résolu comme étant le paquet définit.

L’exemple ci-dessous montre l’ajout d’un paquet comme entrée native de lui-même pour la compilation croisée :

(package
  (name "guile")
  ;; ...

  ;; Lors de la compilation croisée, Guile par exemple dépend
  ;; d'une version native de lui-même. On l'ajoute ici.
  (native-inputs (if (%current-target-system)
                     `(("self" ,this-package))
                     '())))

C’est une erreur que de se référer à this-package en dehors de la définition d’un paquet.

Comme les paquets sont des objets Scheme réguliers qui capturent un graphe de dépendance complet et les procédures de construction associées, il est souvent utile d’écrire des procédures qui prennent un paquet et renvoient une version modifiée de celui-ci en fonction de certains paramètres. En voici quelques exemples.

Procédure Scheme : package-with-c-toolchain package toolchain

Renvoie une variante de package qui utilise toolchain au lieu de la chaîne d’outils GNU C/C++ par défaut. toolchain doit être une liste d’entrées (tuples label/package) fournissant une fonctionnalité équivalente, comme le paquet gcc-toolchain.

L’exemple ci-dessous renvoie une variante du paquet hello construit avec GCC 10.x et le reste de la chaîne d’outils GNU (Binutils et la bibliothèque C GNU) au lieu de la chaîne d’outils par défaut :

(let ((toolchain (specification->package "gcc-toolchain@10")))
  (package-with-c-toolchain hello `(("toolchain" ,toolchain))))

La chaîne d’outils de construction fait partie des entrées implicites des paquets— elle n’est généralement pas listée comme faisant partie des différents champs "entrées" et est à la place récupérée par le système de construction. Par conséquent, cette procédure fonctionne en modifiant le système de compilation de paquet de sorte qu’il utilise toolchain au lieu des valeurs par défaut. Systèmes de construction, pour en savoir plus sur les systèmes de construction.


Précédent: , Monter: Définition des paquets   [Table des matières][Index]

8.2.2 Référence de origin

Cette section documente origins. Une déclaration origin spécifie les données qui doivent être "produites" – téléchargées, généralement – et dont le contenu est connu à l’avance. Les origines sont principalement utilisées pour représenter le code source des paquets (voir Définition des paquets). Pour cette raison, le formulaire origin permet de déclarer des correctifs à appliquer au code source original ainsi que des bribes de code pour le modifier.

Type de données : origin

C’est le type de donnée qui représente l’origine d’un code source.

uri

Un objet contenant l’URI de la source. Le type d’objet dépend de la method (voir plus bas). Par exemple, avec la méthode url-fetch de (guix download), les valeurs valide d’uri sont : une URL représentée par une chaîne de caractères, ou une liste de chaînes de caractères.

method

A monadic procedure that handles the given URI. The procedure must accept at least three arguments: the value of the uri field and the hash algorithm and hash value specified by the hash field. It must return a store item or a derivation in the store monad (voir La monade du dépôt); most methods return a fixed-output derivation (voir Dérivations).

Les méthodes couramment utilisées comprennent url-fetch, qui récupère les données à partir d’une URL, et git-fetch, qui récupère les données à partir d’un dépôt Git (voir ci-dessous).

sha256

Un bytevector contenant le hachage SHA-256 de la source. Cela équivaut à fournir un content-hash Objet SHA256 dans le champ hash décrit ci-dessous.

hash

L’objet content-hash de la source–voir ci-dessous pour savoir comment utiliser content-hash.

Vous pouvez obtenir cette information avec guix download (voir Invoquer guix download) ou guix hash (voir Invoquer guix hash).

file-name (par défaut : #f)

Le nom de fichier à utiliser pour sauvegarder le fichier. Lorsqu’elle est à #f, une valeur par défaut raisonnable est utilisée dans la plupart des cas. Dans le cas où la source est récupérée depuis une URL, le nom de fichier est celui de l’URL. Pour les sources récupérées depuis un outil de contrôle de version, il est recommandé de fournir un nom de fichier explicitement parce que le nom par défaut n’est pas très descriptif.

patches (par défaut : '())

Une liste de noms de fichiers, d’origines ou d’objets simili-fichiers (voir file-like objects) qui pointent vers des correctifs à appliquer sur la source.

Cette liste de correctifs doit être inconditionnelle. En particulier, elle ne peut pas dépendre des valeurs de %current-system ou %current-target-system.

snippet (par défaut : #f)

Une G-expression (voir G-Expressions) ou une S-expression qui sera lancée dans le répertoire des sources. C’est une manière pratique de modifier la source, parfois plus qu’un correctif.

patch-flags (par défaut : '("-p1"))

Une liste de drapeaux à passer à la commande patch.

patch-inputs (par défaut : #f)

Paquets d’entrées ou dérivations pour le processus de correction. Lorsqu’elle est à #f, l’ensemble d’entrées habituellement nécessaire pour appliquer des correctifs est fournit, comme GNU Patch.

modules (par défaut : '())

Une liste de modules Guile qui devraient être chargés pendant le processus de correction et pendant que le lancement du code du champ snippet.

patch-guile (par défaut : #f)

Le paquet Guile à utiliser dans le processus de correction. Lorsqu’elle est à #f, une valeur par défaut raisonnable est utilisée.

Data Type : content-hash value [algorithm]

Construire un objet de hash de contenu pour l’algorithme donné, et avec valeur comme valeur de hachage. Lorsque algorithme est omis, on suppose qu’il s’agit de sha256.

value peut être une chaîne littérale, auquel cas elle est décodée en base32, ou il peut s’agir d’un bytevecteur.

Les options suivantes sont équivalentes :

(content-hash "05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj")
(content-hash "05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj"
              sha256)
(content-hash (base32
               "05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj"))
(content-hash (base64 "kkb+RPaP7uyMZmu4eXPVkM4BN8yhRd8BTHLslb6f/Rc=")
              sha256)

Techniquement, le content-hash est actuellement mis en œuvre sous forme de macro. Il effectue des contrôles de bon sens au moment de l’expansion de la macro, lorsque cela est possible, en s’assurant par exemple que valeur a la bonne taille pour algorithme.

Comme nous l’avons vu plus haut, la manière dont les données auxquelles une origine se réfère exactement sont récupérées est déterminée par son champ method. Le module (guix download) fournit la méthode la plus courante, url-fetch, décrite ci-dessous.

Procédure Scheme : url-fetch url hash-algo hash [name] [#:executable ? #f] Renvoie une dérivation à sortie fixe qui récupère

les données de url (une chaîne de caractères, ou une liste de chaînes de caractères désignant des URLs alternatives), qui est censée avoir un hash hash de type hash-algo (un symbole). Par défaut, le nom du fichier est le nom de base de l’URL ; en option, nom peut spécifier un nom de fichier différent. Lorsque executable? est vrai, rendez le fichier téléchargé exécutable.

Lorsque l’une des URL commence par mirror://, sa partie hôte est alors interprétée comme le nom d’un schéma de miroir, tiré de %mirror-file.

Alternativement, lorsque l’URL commence par file://, renvoie le nom du fichier correspondant dans le dépôt.

De même, le module (guix git-download) définit la méthode d’origine git-download, qui récupère les données d’un dépôt de contrôle de version Git, et le type de données git-reference pour décrire le dépôt et la révision à récupérer.

Procédure Scheme : git-fetch ref hash-algo hash

Renvoie une dérivation à sortie fixe qui va chercher ref, un objet <git-reference>. La sortie est censée avoir un hash récursif hash de type hash-algo (un symbole). Utilisez name comme nom de fichier, ou un nom générique si #f.

Type de données : git-reference

Ce type de données représente une référence Git pour le git-fetch à récupérer.

url

L’URL du dépôt Git à cloner.

commit

Cette chaîne indique soit le commit à récupérer (une chaîne hexadécimale, soit le commit SHA1 complet ou une chaîne de commit "courte" ; cette dernière n’est pas recommandée), soit le tag à récupérer.

recursive? (par défaut : #f)

Ce booléen indique s’il faut aller chercher récursivement les sous-modules de Git.

L’exemple ci-dessous indique la balise v2.10 du dépôt GNU Hello :

(git-reference
  (url "https://git.savannah.gnu.org/git/hello.git")
  (commit "v2.10"))

C’est équivalent à la référence ci-dessous, qui nomme explicitement le commit :

(git-reference
  (url "https://git.savannah.gnu.org/git/hello.git")
  (commit "dc7dc56a00e48fe6f231a58f6537139fe2908fb9"))

For Mercurial repositories, the module (guix hg-download) defines the hg-fetch origin method and hg-reference data type for support of the Mercurial version control system.

Scheme Procedure : hg-fetch ref hash-algo hash [name] Return a fixed-output derivation that fetches ref, a

<hg-reference> object. The output is expected to have recursive hash hash of type hash-algo (a symbol). Use name as the file name, or a generic name if #false.


Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.3 Définition de variantes de paquets

L’une des choses intéressantes avec Guix est qu’à partir d’une définition, on peut facilement dériver des variantes du paquet — pour une version en amont différente, avec des dépendances différentes, des options de compilation différentes, etc. Certains de ces paquets personnalisés peuvent être définis directement par la ligne de commande (voir Options de transformation de paquets). Cette section décrit comment définir des variantes de paquets avec du code. Cela est utile dans les « manifestes » (voir --manifest et dans votre propre collection de paquets (voir Écrire de nouveaux de canaux), entre autres chose !

Comme nous en avons parlé plus tôt, les paquets sont des objets de première classe dans le langage Scheme. Le module (guix packages) fournit la construction package pour définir de nouveaux objets de paquets (voir référence des paquets). La manière la plus simple de définir la variante d’un paquet est d’utiliser le mot-clé inherit avec package. Cela vous permet d’hériter la définition d’un paquet tout en redéfinissant les champs que vous voulez.

Par exemple, étant donné la variable hello, qui contient la définition d’une version récente de GNU Hello, voici comment définir une variante pour la version 2.2 (publiée en 2006, c’est vintage !) :

(use-modules (gnu packages base))    ;pour 'hello'

(define hello-2.2
  (package
    (inherit hello)
    (version "2.2")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-" version
                                  ".tar.gz"))
              (sha256
               (base32
                "0lappv4slgb5spyqbh6yl5r013zv72yqg2pcl30mginf3wdqd8k9"))))))

L’exemple ci-dessus correspond à ce que l’option de transformation des paquets --with-source fait. En substance, hello-2.2 préserve tous les champs de hello, sauf version et source, qu’il remplace. Remarquez que la variable hello originale est toujours là, dans le module (gnu packages base), et n’est pas modifiée. Lorsque vous définissez un paquet personnalisé comme ceci, vous ajoutez en fait une nouvelle définition de paquet ; la version originale est toujours disponible.

Vous pouvez aussi bien définir des variantes avec un ensemble de dépendances différent du paquet d’origine. Par exemple, le paquet gdb par défaut dépend de guile, mais comme c’est une dépendance facultative, vous pouvez définir une variante qu supprime cette dépendance de cette manière :

(use-modules (gnu packages gdb)    ;pour 'gdb'
             (srfi srfi-1))        ;pour 'alist-delete'

(define gdb-sans-guile
  (package
    (inherit gdb)
    (inputs (alist-delete "guile"
                          (package-inputs gdb)))))

L’appel à alist-delete supprime le tuple du champ inputs qui a "guile" comme premier élément (voir SRFI-1 Association Lists dans GNU Guile Reference Manual).

Dans certains cas, vous pouvez trouver cela utile d’écrire des fonctions (« procédures », pour Scheme) qui renvoie un paquet en fonction de certains paramètres. Par exemple, considérez la bibliothèque luasocket pour le langage de programmation lua. Nous voulons créer des paquets luasocket pour les versions majeures de Lua. Une manière de faire est de définir une procédure qui prend un paquet Lua et renvoie un paquet luasocket qui en dépend :

(define (make-lua-socket name lua)
  ;; Renvoie un paquet luasocket construit avec LUA.
  (package
    (name name)
    (version "3.0")
    ;; plusieurs champs ont été omis
    (inputs
     `(("lua" ,lua)))
    (synopsis "Socket library for Lua")))

(define-public lua5.1-socket
  (make-lua-socket "lua5.1-socket" lua-5.1))

(define-public lua5.2-socket
  (make-lua-socket "lua5.2-socket" lua-5.2))

ici nous avons défini les paquets lua5.1-socket et lua5.2-socket en appelant make-lua-socket avec différents arguments. Voir Procedures dans GNU Guile Reference Manual, pour plus d’informations sur les procédures. Avoir des définitions publiques au premier niveau pour ces deux paquets signifie qu’ils sont disponibles depuis la ligne de commande (voir Modules de paquets).

Ce sont des variantes simples de paquets. Par simplicité, le module (guix transformations) fournit une interface de haut niveau qui correspond directement aux options de transformations de paquets plus sophistiquées (voir Options de transformation de paquets) :

Procédure Scheme : options->transformation opts

Renvoie une procédure qui, lorsqu’on lui passe un objet à construire (un paquet, une dérivation, etc), applique les transformations spécifiées par opts et renvoie les objets qui en résultent. opts doit être une liste de pairs de symboles et de chaine comme dans :

((with-branch . "guile-gcrypt=master")
 (without-tests . "libgcrypt"))

Chaque nom de symbole nomme une transformation et la chaine correspondante est un argument pour cette transformation.

Par exemple, un manifeste équivalent à cette commande :

guix build guix \
  --with-branch=guile-gcrypt=master \
  --with-debug-info=zlib

... ressemblerait à ceci :

(use-modules (guix transformations))

(define transform
  ;; La précuder de transformation des paquets.
  (options->transformation
   '((with-branch . "guile-gcrypt=master")
     (with-debug-info . "zlib"))))

(packages->manifest
 (list (transform (specification->package "guix"))))

La procédure options->transformation est pratique, mais elle n’est peut-être pas aussi flexible que vous pourriez le souhaiter. Comment est-elle implémentée ? Le lecteur attentif aura sans doute remarqué que la plupart des options de transformation des paquets va plus loin que les changements superficiels montrés dans les premiers exemples de cette sections : ils font de la réécriture d’entrées, où le graphe de dépendance d’un paquet est réécrit en remplaçant des entrées spécifiques par d’autres.

La procédure package-input-rewriting de (guix packages) implémente la réécriture du graphe de dépendance, pour remplacer des paquets dans le graphe.

Procédure Scheme : package-input-rewriting replacements [nom-réécrit] [#:deep ? #t] Renvoie une procédure qui, lorsqu'elle est

passée à un paquet, remplace ses dépendances directes et indirectes, y compris les entrées implicites lorsque deep? est vrai, selon replacements. replacements est une liste de paires de paquets ; le premier élément de chaque paire est le paquet à remplacer, et le second est le remplacement.

De manière facultative, nom-réécrit est une procédure à un argument qui prend le nom d’un paquet et renvoie son nouveau nom après l’avoir réécrit.

Regardez cet exemple :

(define libressl-instead-of-openssl
  ;; Cette procédure remplace OPENSSL par LIBRESSL,
  ;; récursivement.
  (package-input-rewriting `((,openssl . ,libressl))))

(define git-with-libressl
  (libressl-instead-of-openssl git))

Ici nous définissons d’abord une procédure de réécriture qui remplace openssl par libressl. Ensuite nous l’utilisons pour définir une variante du paquet git qui utilise libressl plutôt que openssl. cela est exactement ce que l’option en ligne de commande --with-input fait (voir --with-input).

La variante suivante de package-input-rewriting peut repérer les paquets à remplacer par nom à la place de leur identité.

Procédure Scheme : package-input-rewriting/spec remplacements[#:deep? #t]

Renvoie une procédure qui, étant donné un paquet, applique les remplacements donnés à tout le graphe du paquet, y compris les entrées implicites, à moins que deep? ne soit faux. replacements est une liste de paires spécifications/procédures ; chaque spécification est une spécification de paquet telle que "gcc" ou "guile@2", et chaque procédure prend un paquet correspondant et renvoie un remplacement pour ce paquet.

L’exemple ci-dessus pourrait être réécrit de cette manière :

(define libressl-instead-of-openssl
  ;; Remplace tous les paquets nommés « openssl » par LibreSSL.
  (package-input-rewriting/spec `(("openssl" . ,(const libressl)))))

Le différence clef est que, cette fois-ci, les paquets correspondent à la spécification et non à l’identité. En d’autres termes, tout paquet dans le graphe qui est appelé openssl sera remplacé.

Une procédure plus générique pour réécrire un graphe de dépendance d’un paquet est package-mapping : elle supporte n’importe quel changement dans les nœuds du graphe.

Procédure Scheme : package-mapping proc [cut?] [#:deep? #f]

Renvoie une procédure qui, pour un paquet donné, applique proc à tous les paquets dont il dépend et renvoie le paquet résultant. La procédure arrête la récursion lorsque cut? renvoie true pour un paquet donné. Lorsque deep? est vrai, proc est également appliqué aux entrées implicites.


Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.4 Systèmes de construction

Chaque définition de paquet définie un système de construction et des arguments pour ce système de construction (voir Définition des paquets). Ce champ build-system représente la procédure de construction du paquet, ainsi que des dépendances implicites pour cette procédure de construction.

Les systèmes de construction sont des objets <build-system>. L’interface pour les créer et les manipuler est fournie par le module (guix build-system) et les systèmes de construction eux-mêmes sont exportés par des modules spécifiques.

Sous le capot, les systèmes de construction compilent d’abord des objets paquets en sacs. Un sac est comme un paquet, mais avec moins de décoration — en d’autres mots, un sac est une représentation à bas-niveau d’un paquet, qui inclus toutes les entrées de ce paquet, dont certaines ont été implicitement ajoutées par le système de construction. Cette représentation intermédiaire est ensuite compilée en une dérivation (voir Dérivations). Le package-with-c-toolchain est un exemple d’une manière de modifier les entrées implicites que le système de construction d’un paquet récupère (voir package-with-c-toolchain).

Les systèmes de construction acceptent une liste d’arguments facultatifs. Dans les définitions de paquets, ils sont passés via le champ arguments (voir Définition des paquets). Ce sont typiquement des arguments par mot-clef (voir keyword arguments in Guile dans GNU Guile Reference Manual). La valeur de ces arguments est habituellement évaluée dans la strate de construction — c.-à-d. par un processus Guile lancé par le démon (voir Dérivations).

Le système de construction principal est le gnu-build-system qui implémente les procédures de construction standard pour les paquets GNU et de nombreux autres. Il est fournit par le module (guix build-system gnu).

Variable Scheme : gnu-build-system

gnu-build-system représente le système de construction GNU et ses variantes (voir configuration and makefile conventions dans GNU Coding Standards).

En résumé, les paquets qui l’utilisent sont configurés, construits et installés avec la séquence ./configure && make && make check && make install habituelle. En pratique, des étapes supplémentaires sont souvent requises. Toutes ces étapes sont séparées dans des phases différentes, notamment16:

unpack

Décompresse l’archive des sources et se déplace dans l’arborescence des sources fraîchement extraites. Si la source est en fait un répertoire, le copie dans l’arborescence de construction et entre dans ce répertoire.

patch-source-shebangs

Corrige les shebangs (#!) rencontrés dans les fichiers pour qu’ils se réfèrent aux bons noms de fichiers. Par exemple, elle change #!/bin/sh en #!/gnu/store/…-bash-4.3/bin/sh.

configure

Lance le script configure avec un certain nombre d’options par défaut, comme --prefix=/gnu/store/…, ainsi que les options spécifiées par l’argument #:configure-flags.

build

Lance make avec la liste des drapeaux spécifiés avec #:make-flags. Si l’argument #:parallel-build? est vrai (par défaut), construit avec make -j.

check

Lance make check, ou une autre cible spécifiée par #:test-target, à moins que #:tests? #f ne soit passé. Si l’argument #:parallel-tests? est vrai (par défaut), lance make check -j.

install

Lance make install avec les drapeaux listés dans #:make-flags.

patch-shebangs

Corrige les shebangs des fichiers exécutables installés.

strip

Nettoie les symboles de débogage dans les fichiers ELF (à moins que #:strip-binaries? ne soit faux), les copie dans la sortie debug lorsqu’elle est disponible (voir Installer les fichiers de débogage).

Le module du côté du constructeur (guix build gnu-build-system) définie %standard-phases comme la liste par défaut des phases de construction. %standard-phases est une liste de paires de symboles et de procédures, où la procédure implémente la phase en question.

Voir Phases de construction, pour plus d’informations sur les phases de construction et les moyens de les personnaliser.

En plus, ce système de construction s’assure que l’environnement « standard » pour les paquets GNU est disponible. Cela inclus des outils comme GCC, libc, Coreutils, Bash, Make, Diffutils, grep et sed (voir le module (guix build-system gnu) pour une liste complète). Nous les appelons les entrées implicites d’un paquet parce que la définition du paquet ne les mentionne pas.

D’autres objets <build-system> sont définis pour supporter d’autres conventions et outils utilisés par les paquets de logiciels libres. Ils héritent de la plupart de gnu-build-system et diffèrent surtout dans l’ensemble des entrées implicites ajoutées au processus de construction et dans la liste des phases exécutées. Certains de ces systèmes de construction sont listés ci-dessous.

Variable Scheme : ant-build-system

Cette variable est exportée par (guix build-system ant). Elle implémente la procédure de construction pour les paquets Java qui peuvent être construits avec l’outil de construction Ant.

Elle ajoute à la fois ant et the kit de développement Java (JDK) fournit par le paquet icedtea à l’ensemble des entrées. Des paquets différents peuvent être spécifiés avec les paramètres #:ant et #:jdk respectivement.

Lorsque le paquet d’origine ne fournit pas de fichier de construction Ant acceptable, le paramètre #:jar-name peut être utilisé pour générer un fichier de construction Ant build.xml minimal, avec des tâches pour construire l’archive jar spécifiée. Dans ce cas, le paramètre #:source-dir peut être utilisé pour spécifier le sous-répertoire des sources, par défaut « src ».

The #:main-class parameter can be used with the minimal ant buildfile to specify the main class of the resulting jar. This makes the jar file executable. The #:test-include parameter can be used to specify the list of junit tests to run. It defaults to (list "**/*Test.java"). The #:test-exclude can be used to disable some tests. It defaults to (list "**/Abstract*.java"), because abstract classes cannot be run as tests.

Le paramètre #:build-target peut être utilisé pour spécifier la tâche Ant qui devrait être lancée pendant la phase build. Par défaut la tâche « jar » sera lancée.

Variable Scheme : android-ndk-build-system

Cette variable est exportée par (guix build-system android-ndk). Elle implémente une procédure de construction pour les paquets du NDK Android (native development kit) avec des processus de construction spécifiques à Guix.

Le système de compilation suppose que les paquets installent leurs fichiers d’interface publique (en-tête) dans le sous-répertoire include de la sortie out et leurs bibliothèques dans le sous-répertoire lib de la sortie out.

Il est aussi supposé que l’union de toutes les dépendances d’un paquet n’a pas de fichiers en conflit.

Pour l’instant, la compilation croisée n’est pas supportées — donc pour l’instant les bibliothèques et les fichiers d’en-têtes sont supposés être des outils de l’hôte.

Variable Scheme : asdf-build-system/source
Variable Scheme : asdf-build-system/sbcl
Variable Scheme : asdf-build-system/ecl

These variables, exported by (guix build-system asdf), implement build procedures for Common Lisp packages using “ASDF”. ASDF is a system definition facility for Common Lisp programs and libraries.

The asdf-build-system/source system installs the packages in source form, and can be loaded using any common lisp implementation, via ASDF. The others, such as asdf-build-system/sbcl, install binary systems in the format which a particular implementation understands. These build systems can also be used to produce executable programs, or lisp images which contain a set of packages pre-loaded.

Le système de construction utilise des conventions de nommage. Pour les paquets binaires, le nom du paquet devrait être préfixé par l’implémentation lisp, comme sbcl- pour asdf-build-system/sbcl.

En plus, le paquet source correspondant devrait étiquetté avec la même convention que les paquets python (voir Modules python), avec le préfixe cl-.

In order to create executable programs and images, the build-side procedures build-program and build-image can be used. They should be called in a build phase after the create-asdf-configuration phase, so that the system which was just built can be used within the resulting image. build-program requires a list of Common Lisp expressions to be passed as the #:entry-program argument.

By default, all the .asd files present in the sources are read to find system definitions. The #:asd-files parameter can be used to specify the list of .asd files to read. Furthermore, if the package defines a system for its tests in a separate file, it will be loaded before the tests are run if it is specified by the #:test-asd-file parameter. If it is not set, the files <system>-tests.asd, <system>-test.asd, tests.asd, and test.asd will be tried if they exist.

If for some reason the package must be named in a different way than the naming conventions suggest, or if several systems must be compiled, the #:asd-systems parameter can be used to specify the list of system names.

Variable Scheme : cargo-build-system

Cette variable est exportée par (guix build-system cargo). Elle supporte les construction de paquets avec Cargo, le système de construction du langage de programmation Rust.

Celà ajoute rustc et cargo à l’ensemble des entrées. Un autre paquet Rust peut être spécifié avec le paramètre #:rust.

Les dépendances régulières de cargo doivent être ajoutées à la définition du paquet via le paramètre #:cargo-inputs sous la forme d’une liste de paires de noms et de spécifications, où la spécification peut être un paquet ou une définition de source. Notez que la spécification doit évaluer un chemin vers une arhive gzippée qui inclut un fichier Cargo.toml à sa racine, sinon elle sera ignorée. De même, les dépendances de développement de cargo doivent être ajoutées à la définition du paquet via le paramètre #:cargo-development-inputs.

Dans sa phase configure, ce système de construction mettra à disposition de cargo toutes les entrées sources spécifiées dans les paramètres #:cargo-inputs et #:cargo-development-inputs. Il supprimera également un fichier Cargo.lock inclus, qui sera recréé par cargo pendant la phase build. La phase instal installe les binaires définis par la caisse.

Scheme Variable : chicken-build-system

This variable is exported by (guix build-system chicken). It builds CHICKEN Scheme modules, also called “eggs” or “extensions”. CHICKEN generates C source code, which then gets compiled by a C compiler, in this case GCC.

This build system adds chicken to the package inputs, as well as the packages of gnu-build-system.

The build system can’t (yet) deduce the egg’s name automatically, so just like with go-build-system and its #:import-path, you should define #:egg-name in the package’s arguments field.

For example, if you are packaging the srfi-1 egg:

(arguments '(#:egg-name "srfi-1"))

Egg dependencies must be defined in propagated-inputs, not inputs because CHICKEN doesn’t embed absolute references in compiled eggs. Test dependencies should go to native-inputs, as usual.

Variable Scheme : copy-build-system

Cette variable est exportée par (guix build-system copy). Il prend en charge la construction de paquets simples qui ne nécessitent pas beaucoup de compilation, la plupart du temps juste le déplacement de fichiers.

Celà ajoute une grande partie des paquets gnu-build-system à l’ensemble des entrées. De ce fait, le copy-build-system n’a pas besoin de tout le code passe-partout souvent nécessaire pour le trivial-build-system.

Pour simplifier davantage le processus d’installation des fichiers, un argument #:install-plan est exposé pour permettre au packager de spécifier quels fichiers vont où. Le plan d’installation est une liste de (source cible [filtres]). Les filtres sont facultatifs.

Exemples :

Variable Scheme : clojure-build-system

Cette variable est exportée par (guix build-system clojure). Elle implémente une procédure de construction des paquets simple qui utilise le bon vieux compile de Clojure. La compilation croisée n’est pas encore supportée.

Elle ajoute clojure, icedtea et zip à l’ensemble des entrées. Des paquets différents peuvent être spécifiés avec les paramètres #:clojure, #:jdk et #:zip.

Une liste de répertoires sources, de répertoires de tests et de noms de jar peuvent être spécifiés avec les paramètres #:source-dirs, #:test-dirs et #:jar-names. Le répertoire de construction est la classe principale peuvent être spécifiés avec les paramètres #:compile-dir et #:main-class. Les autres paramètres sont documentés plus bas.

Ce système de construction est une extension de ant-build-system, mais avec les phases suivantes modifiées :

build

Cette phase appelle compile en Clojure pour compiler les fichiers sources et lance jar pour créer les fichiers jar à partir des fichiers sources et des fichiers compilés en suivant la liste d’inclusion et d’exclusion spécifiées dans #:aot-include et #:aot-exclude. La liste d’exclusion a la priorité sur la liste d’inclusion. Ces listes consistent en des symboles représentant des bibliothèque Clojure ou le mot clef spécial #:all, représentant toutes les bibliothèques Clojure trouvées dans les répertoires des sources. Le paramètre #:omit-source? décide si les sources devraient être incluses dans les fichiers jar.

check

Cette phase lance les tests en suivant les liste d’inclusion et d’exclusion spécifiées dans #:test-include et #:test-exclude. Leur signification est analogue à celle de #:aot-include et #:aot-exclude, sauf que le mot-clef spécial #:all signifie maintenant toutes les bibliothèques Clojure trouvées dans les répertoires de tests. Le paramètre #:tests? décide si les tests devraient être lancés.

install

Cette phase installe tous les fichiers jar précédemment construits.

En dehors de cela, le système de construction contient aussi la phase suivante :

install-doc

Cette phase installe tous les fichiers dans le répertoire de plus haut niveau dont le nom correspond à %doc-regex. On peut spécifier une regex différente avec le paramètre #:doc-regex. Tous les fichiers (récursivement) dans les répertoires de documentations spécifiés dans #:doc-dirs sont aussi installés.

Variable Scheme : cmake-build-system

Cette variable est exportée par (guix build-system cmake). Elle implémente la procédure de construction des paquets qui utilisent l’outil de construction CMake.

Elle ajoute automatiquement le paquet cmake à l’ensemble des entrées. Le paquet utilisé peut être spécifié par le paramètre #:cmake.

Le paramètre #:configure-flags est pris comme une liste de drapeaux à passer à la commande cmake. Le paramètre #:build-type spécifie en termes abstrait les drapeaux passés au compilateur ; sa valeur par défaut est "RelWithDebInfo" (ce qui veut dire « mode public avec les informations de débogage » en plus court), ce qui signifie en gros que le code sera compilé avec -O2 -g comme pour les paquets autoconf par défaut.

Variable Scheme : dune-build-system

Cette variable est exportée par (guix build-system dune). Elle prend en charge la construction des paquets qui utilisent Dune, un outil de construction pour le langage de programmation OCaml. Elle est implémentée comme une extension de ocaml-build-system décrit plus bas. En tant que tel, les paramètres #:ocaml et #:findlib peuvent être passés à ce système de construction.

Elle ajoute automatiquement le paquet dune à l’ensemble des entrées. Le paquet utilisé peut être spécifié par le paramètre #:dune.

Il n’y a pas de phase configure parce que les paquets dune n’ont habituellement pas besoin d’être configurés. Le paramètre #:build-flags est interprété comme une liste de drapeaux pour la commande dune pendant la construction.

Le paramètre #:jbuild? peut être passé pour utiliser la commande jbuild à la place de la commande dune plus récente pour la construction d’un paquet. Sa valeur par défaut est #f.

Le paramètre #:package peut être passé pour spécifié un nom de paquet, ce qui est utile lorsqu’un paquet contient plusieurs paquets et que vous voulez n’en construire qu’un. C’est équivalent à passer l’argument -p à dune.

Variable Scheme : go-build-system

Cette variable est exportée par (guix build-system go). Elle implémente la procédure pour les paquets Go utilisant les mécanismes de construction Go standard.

L’utilisateur doit fournir une valeur à la clef #:import-path et, dans certains cas, #:unpack-path. Le chemin d’import correspond au chemin dans le système de fichiers attendu par le script de construction du paquet et les paquets qui s’y réfèrent et fournit une manière unique de se référer à un paquet Go. Il est typiquement basé sur une combinaison de l’URI du code source du paquet et d’une structure hiérarchique du système de fichier. Dans certains cas, vous devrez extraire le code source du paquet dans une structure de répertoires différente que celle indiquée par le chemin d’import et #:unpack-path devrait être utilisé dans ces cas-là.

Les paquets qui fournissent des bibliothèques Go devraient installer leur code source dans la sortie du paquet. La clef #:install-source?, qui vaut #t par défaut, contrôle l’installation du code source. Elle peut être mise à #f pour les paquets qui ne fournissent que des fichiers exécutables.

Variable Scheme : glib-or-gtk-build-system

Cette variable est exportée par (guix build-system glib-or-gtk). Elle est conçue pour être utilisée par des paquets qui utilisent GLib ou GTK+.

Ce système de construction ajoute les deux phases suivantes à celles définies par gnu-build-system :

glib-or-gtk-wrap

La phase glib-or-gtk-wrap garantit que les programmes dans bin/ sont capables de trouver les « schémas » GLib et GTK+ modules. Cela est réalisé en enveloppant les programmes dans des scripts de lancement qui définissent de manière appropriée les variables d’environnement XDG_DATA_DIRS et GTK_PATH.

Il est possible d’exclure des sorties spécifiques de ce processus d’enveloppage en listant leur nom dans le paramètre #:glib-or-gtk-wrap-excluded-outputs. C’est utile lorsqu’une sortie est connue pour ne pas contenir de binaires GLib ou GTK+, et où l’enveloppe ajouterait une dépendance inutile vers GLib et GTK+.

glib-or-gtk-compile-schemas

La phase glib-or-gtk-compile-schemas s’assure que tous les schémas GSettings de GLib sont compilés. La compilation est effectuée par le programme glib-compile-schemas. Il est fournit par le paquet glib:bin qui est automatiquement importé par le système de construction. Le paquet glib qui fournit glib-compile-schemas peut être spécifié avec le paramètre #:glib.

Ces deux phases sont exécutées après la phase install.

Variable Scheme : guile-build-system

Ce système de construction sert aux paquets Guile qui consistent exclusivement en code Scheme et qui sont si simple qu’ils n’ont même pas un makefile, sans parler d’un script configure. Il compile le code Scheme en utilisant guild compile (voir Compilation dans GNU Guile Reference Manual) et installe les fichiers .scm et .go aux bons emplacements. Il installe aussi la documentation.

Ce système de construction supporte la compilation croisée en utilisant l’option --target de guild compile.

Les paquets construits avec guile-build-system doivent fournir un paquet Guile dans leur champ native-inputs.

Variable Scheme : julia-build-system

This variable is exported by (guix build-system julia). It implements the build procedure used by julia packages, which essentially is similar to running ‘julia -e 'using Pkg; Pkg.add(package)'’ in an environment where JULIA_LOAD_PATH contains the paths to all Julia package inputs. Tests are run by calling /test/runtests.jl.

The Julia package name is read from the file Project.toml. This value can be overridden by passing the argument #:julia-file-name (which must be correctly capitalized).

For packages requiring shared library dependencies, you may need to write the /deps/deps.jl file manually. It’s usually a line of const variable = /gnu/store/library.so for each dependency, plus a void function check_deps() = nothing.

Some older packages that aren’t using Package.toml yet, will require this file to be created, too. The function julia-create-package-toml helps creating the file. You need to pass the outputs and the source of the package, it’s name (the same as the file-name parameter), the package uuid, the package version, and a list of dependencies specified by their name and their uuid.

Variable Scheme : maven-build-system

Cette variable est exportée par (guix build-system maven). Elle implémente une procédure de construction pour les paquets Maven. Maven est un outil de gestion des dépendances et du cycle de vie pour Java. Un·e utilisateur·rice de Maven spécifie les dépendances et les plugins dans un fichier pom.xml que Maven lit. Lorsque Maven n’a pas l’une des dépendances ou l’un des plugins dans son dépôt, il les télécharge et les utilise pour construire le paquet.

Le système de construction de maven garantit que maven n’essaiera pas de télécharger une dépendance en s’exécutant en mode hors ligne. Maven échouera si une dépendance est manquante. Avant de lancer Maven, le fichier pom.xml (et sous-projets) sont modifiés pour spécifier la version des dépendances et des plugins qui correspondent aux versions disponibles dans l’environnement de construction de guix. Les dépendances et plugins doivent être installés dans le faux dépôt maven à lib/m2, et sont liés par un lien symbolique à un dépôt approprié avant que maven ne soit lancé. Maven a pour instruction d’utiliser ce dépôt pour la construction et y installe les artefacts construits. Les fichiers modifiés sont copiés dans le répertoire lib/m2 de la sortie du paquet.

Vous pouvez spécifier un fichier pom.xml avec l’argument #:pom-file, ou bien laisser le système de construction utiliser le fichier par défaut pom.xml dans les sources.

Dans le cas où vous avez besoin de spécifier manuellement une version de dépendances, vous pouvez utiliser l’argument #:local-packages. Il prend une liste d’association dont la clé est le groupId du paquet et sa valeur est une liste d’association où la clé est l’artefactId du paquet et sa valeur est la version que vous souhaitez remplacer dans le fichier pom.xml.

Certains paquets utilisent des dépendances ou des plugins qui ne sont pas utiles au moment de l’exécution ou de la compilation dans Guix. Vous pouvez modifier le fichier pom.xml pour les supprimer en utilisant l’argument #:exclude. Sa valeur est une liste d’association où la clé est le groupId du plugin ou de la dépendance que vous voulez supprimer, et la valeur est une liste d’artifactId que vous voulez supprimer.

Vous pouvez remplacer les paquets jdk et maven par défaut avec l’argument correspondant, #:jdk et #:maven.

L’argument #:maven-plugins est une liste de plugins maven utilisés pendant la construction, avec le même format que le champ inputs de la déclaration du paquet. Sa valeur par défaut est (default-maven-plugins) qui est également exportée.

Variable Scheme : minify-build-system

Cette variable est exportée par (guix build-system minify). Elle implémente une procédure de minification pour des paquets JavaScript simples.

Elle ajoute uglify-js à l’ensemble des entrées et l’utilise pour compresser tous les fichiers JavaScript du répertoire src. Un minifieur différent peut être spécifié avec le paramètre #:uglify-js mais il est attendu que ce paquet écrive le code minifié sur la sortie standard.

Lorsque les fichiers JavaScript d’entrée ne sont pas situés dans le répertoire src, le paramètre #:javascript-files peut être utilisé pour spécifier une liste de noms de fichiers à donner au minifieur.

Variable Scheme : ocaml-build-system

Cette variable est exportée par (guix build-system ocaml). Elle implémente une procédure de construction pour les paquets OCaml qui consiste à choisir le bon ensemble de commande à lancer pour chaque paquet. Les paquets OCaml peuvent demander des commandes diverses pour être construit. Ce système de construction en essaye certaines.

Lorsqu’un fichier setup.ml est présent dans le répertoire de plus haut niveau, elle lancera ocaml setup.ml -configure, ocaml setup.ml -build et ocaml setup.ml -install. Le système de construction supposera que ces fichiers ont été générés par OASIS et prendra soin d’initialiser le préfixe et d’activer les tests s’ils ne sont pas désactivés. Vous pouvez passer des drapeaux de configuration et de construction avec #:configure-flags et #:build-flags. La clef #:test-flags peut être passée pour changer l’ensemble des drapeaux utilisés pour activer les tests. La clef #:use-make? peut être utilisée pour outrepasser ce système dans les phases de construction et d’installation.

Lorsque le paquet a un fichier configure, il est supposé qu’il s’agit d’un script configure écrit à la main qui demande un format différent de celui de gnu-build-system. Vous pouvez ajouter plus de drapeaux avec la clef #:configure-flags.

Lorsque le paquet a un fichier Makefile (ou #:use-make? vaut #t), il sera utilisé et plus de drapeaux peuvent être passés à la construction et l’installation avec la clef #:make-flags.

Enfin, certains paquets n’ont pas ces fichiers mais utilisent un emplacement plus ou moins standard pour leur système de construction. Dans ce cas, le système de construction lancera ocaml pkg/pkg.ml ou pkg/build.ml et prendra soin de fournir le chemin du module findlib requis. Des drapeaux supplémentaires peuvent être passés via la clef #:bulid-flags. L’installation se fait avec opam-installer. Dans ce cas, le paquet opam doit être ajouté au champ native-inputs de la définition du paquet.

Remarquez que la plupart des paquets OCaml supposent qu’ils seront installés dans le même répertoire qu’OCaml, ce qui n’est pas ce que nous voulons faire dans Guix. En particulier, ils installeront leurs fichiers .so dans leur propre répertoire de module, ce qui est normalement correct puisqu’il s’agit du répertoire du compilateur OCaml. Dans Guix en revanche, ces bibliothèques ne peuvent pas y être trouvées et on utilise CAML_LD_LIBRARY_PATH à la place. Cette variable pointe vers lib/ocaml/site-lib/stubslibs et c’est là où les bibliothèques .so devraient être installées.

Variable Scheme : python-build-system

Cette variable est exportée par (guix build-system python). Elle implémente la procédure de construction plus ou moins standard utilisée pour les paquets Python, qui consiste à lancer python setup.py build puis python setup.py install --prefix=/gnu/store/….

Pour les paquets qui installent des programmes autonomes Python dans bin/, elle prend soin d’envelopper ces binaires pour que leur variable d’environnement PYTHONPATH pointe vers toutes les bibliothèques Python dont ils dépendent.

Le paquet Python utilisé pour effectuer la construction peut être spécifié avec le paramètre #:python. C’est une manière utile de forcer un paquet à être construit avec une version particulière de l’interpréteur python, ce qui peut être nécessaire si le paquet n’est compatible qu’avec une version de l’interpréteur.

Par défaut, guix appelle setup.py sous le contrôle de setuptools, tout comme pip le fait. Certains paquets ne sont pas compatibles avec setuptools (et pip), vous pouvez donc le désactiver en réglant le paramètre #:use-setuptools? sur #f.

Variable Scheme : perl-build-system

Cette variable est exportée par (guix build-system perl). Elle implémente la procédure de construction standard des paquets Perl, qui consiste soit à lancer perl Build.PL --prefix=/gnu/store/…, suivi de Build et Build install ; ou à lancer perl Makefile.PL PREFIX=/gnu/store/…, suivi de make et make install, en fonction de la présence de Build.PL ou Makefile.PL dans la distribution du paquet. Le premier a la préférence si Build.PL et Makefile.PL existent tous deux dans la distribution du paquet. Cette préférence peut être inversée en spécifiant #t pour le paramètre #:make-maker?.

L’invocation initiale de perl Makefile.PL ou perl Build.PL passe les drapeaux spécifiés par le paramètre #:make-maker-flags ou #:module-build-flags, respectivement.

Le paquet Perl utilisé peut être spécifié avec #:perl.

Scheme Variable : renpy-build-system

This variable is exported by (guix build-system renpy). It implements the more or less standard build procedure used by Ren’py games, which consists of loading #:game once, thereby creating bytecode for it.

It further creates a wrapper script in bin/ and a desktop entry in share/applications, both of which can be used to launch the game.

Which Ren’py package is used can be specified with #:renpy. Games can also be installed in outputs other than “out” by using #:output.

Variable Scheme : qt-build-system

Cette variable est exportée par (guix build-system qt). Elle est destinée à être employée avec des applications utilisant Qt ou KDE.

Ce système de construction ajoute les deux phases suivantes à celles définies par gnu-build-system :

check-setup

La phase check-setup prépare l’environnement pour l’exécution des contrôles tels qu’ils sont couramment utilisés par les programmes de test Qt. Pour l’instant, elle ne définit que quelques variables d’environnement : QT_QPA_PLATFORM=offscreen, DBUS_FATAL_WARNINGS=0 et CTEST_OUTPUT_ON_FAILURE=1.

Cette phase est ajoutée avant la phase check. C’est une phase distincte pour faciliter l’ajustement si nécessaire.

qt-wrap

La phase qt-wrap recherche les chemins des plugins Qt5, les chemins QML et certains XDG dans les entrées et sorties. Si un chemin est trouvé, tous les programmes des répertoires bin/, sbin/, libexec/ et lib/libexec/ de la sortie sont enveloppés dans des scripts définissant les variables d’environnement nécessaires.

Il est possible d’exclure des sorties de paquets spécifiques de ce processus d’emballage en listant leurs noms dans le paramètre #:qt-wrap-excluded-outputs. Ceci est utile lorsqu’une sortie est connue pour ne pas contenir de binaires Qt, et où le wrapping ajouterait gratuitement une dépendance de cette sortie à Qt, KDE, ou autre.

Cette phase est exécutée après la phase install.

Variable Scheme : r-build-system

Cette variable est exportée par (guix build-system r). Elle implémente la procédure de compilation utilisée par les paquets R, qui consiste en substance à exécuter ‘R CMD INSTALL --library=/gnu/store/…’ dans un environnement où R_LIBS_SITE contient les chemins de toutes les entrées des paquets R. Les tests sont exécutés après l’installation en utilisant la fonction R tools::testInstalledPackage.

Variable Scheme : rakudo-build-system

This variable is exported by (guix build-system rakudo). It implements the build procedure used by Rakudo for Perl6 packages. It installs the package to /gnu/store/…/NAME-VERSION/share/perl6 and installs the binaries, library files and the resources, as well as wrap the files under the bin/ directory. Tests can be skipped by passing #f to the tests? parameter.

Le paquet rakudo utilisé peut être spécifié avec rakudo. Le paquet perl6-tap-harness utilisé pour les tests peut être spécifié avec #:prove6 ou supprimé en passant #f au paramètre with-prove6?. Le paquet perl6-zef utilisé pour les tests et l’installation peut être spécifié avec #:ef ou supprimé en passant #f au paramètre with-zef?.

Variable Scheme : texlive-build-system

Cette variable est exportée par (guix build-system texlive). Elle est utilisée pour construire des paquets TeX en mode batch avec le moteur spécifié. Le système de construction initialise la variable TEXINPUTS pour trouver tous les fichiers source TeX dans ses entrées.

Par défaut, elle lance luatex sur tous les fichiers qui se terminent par ins. Un moteur et un format différent peuvent être spécifiés avec l’argument #:tex-format. Plusieurs cibles de constructions peuvent être indiquées avec l’argument #:build-targets qui attend une liste de noms de fichiers. Le système de construction ajoute uniquement texlive-bin et texlive-latex-base (de (gnu packages tex) à la liste des entrées. Les deux peuvent être remplacés avec les arguments #:texlive-bin et #:texlive-latex-base, respectivement.

Le paramètre #:tex-directory dit au système de construction où installer les fichiers construit dans l’arbre texmf.

Variable Scheme : ruby-build-system

Cette variable est exportée par (guix build-system ruby). Elle implémenter la procédure de construction RubyGems utilisée par les paquets Ruby qui consiste à lancer gem build suivi de gem install.

Le champ source d’un paquet qui utilise ce système de construction référence le plus souvent une archive gem, puisque c’est le format utilisé par les personnes qui développent en Ruby quand elles publient leur logiciel. Le système de construction décompresse l’archive gem, éventuellement en corrigeant les sources, lance la suite de tests, recompresse la gemme et l’installe. En plus, des répertoires et des archives peuvent être référencés pour permettre de construire des gemmes qui n’ont pas été publiées depuis Git ou une archive de sources traditionnelle.

Le paquet Ruby utilisé peut être spécifié avec le paramètre #:ruby. Une liste de drapeaux supplémentaires à passer à la commande gem peut être spécifiée avec le paramètre #:gem-flags.

Variable Scheme : waf-build-system

Cette variable est exportée par (guix build-system waf). Elle implémente une procédure de construction autour du script waf. Les phases usuelles — configure, build et install — sont implémentée en passant leur nom en argument au script waf.

Le script waf est exécuté par l’interpréteur Python. Le paquet Python utilisé pour lancer le script peut être spécifié avec le paramètre #:python.

Variable Scheme : scons-build-system

Cette variable est exportée par (guix build-system scons). Elle implémente la procédure de construction utilisée par l’outil de construction SCons. Ce système de construction lance scons pour construire le paquet, scons test pour lancer les tests puis scons install pour installer le paquet.

Des drapeaux supplémentaires à passer à scons peuvent être spécifiés avec le paramètre #:scons-flags. Les cibles de construction et d’installation par défaut peuvent être remplacées respectivement par les paramètres #:build-targets et #:install-targets. La version de Python utilisée pour exécuter SCons peut être spécifiée en sélectionnant le paquet SCons approprié avec le paramètre #:scons.

Variable Scheme : haskell-build-system

Cette variable est exportée par (guix build-system haskell). Elle implémente la procédure de construction Cabal utilisée par les paquets Haskell, qui consiste à lancer runhaskell Setup.hs configure --prefix=/gnu/store/… et runhaskell Setup.hs build. Plutôt que d’installer le paquets en lançant runhaskell Setup.hs install, pour éviter d’essayer d’enregistrer les bibliothèques dans le répertoire du dépôt en lecture-seule du compilateur, le système de construction utilise runhaskell Setup.hs copy, suivi de runhaskell Setup.hs register. En plus, le système de construction génère la documentation du paquet en lançant runhaskell Setup.hs haddock, à moins que #:haddock? #f ne soit passé. Des paramètres facultatifs pour Haddock peuvent être passés à l’aide du paramètre #:haddock-flags. Si le fichier Setup.hs n’est pas trouvé, le système de construction cherchera Setup.lhs à la place.

Le compilateur Haskell utilisé peut être spécifié avec le paramètre #:haskell qui a pour valeur par défaut ghc.

Variable Scheme : dub-build-system

Cette variable est exportée par (guix build-system dub). Elle implémente la procédure de construction Dub utilisée par les paquets D qui consiste à lancer dub build et dub run. L’installation est effectuée en copiant les fichiers manuellement.

Le compilateur D utilisé peut être spécifié avec le paramètre #:ldc qui vaut par défaut ldc.

Variable Scheme : emacs-build-system

Cette variable est exportée par (guix build-system emacs). Elle implémente une procédure d’installation similaire au système de gestion de paquet d’Emacs lui-même (voir Packages dans The GNU Emacs Manual).

Celà crée d’abord le fichier package-autoloads.el, puis compile tous les fichiers Emacs Lisp en bytecode. Contrairement au système de gestion de paquets d’Emacs, les fichiers de documentation info sont déplacés dans le répertoire standard et le fichier dir est supprimé. Les fichiers du paquet Elisp sont directement installés sous share/emacs/site-lisp.

Variable Scheme : font-build-system

Cette variable est exportée par (guix build-system font). Elle implémente une procédure d’installation pour les paquets de polices où des fichiers de polices TrueType, OpenType, etc. sont fournis en amont et n’ont qu’à être copiés à leur emplacement final. Elle copie les fichiers de polices à l’emplacement standard dans le répertoire de sortie.

Variable Scheme : meson-build-system

Cette variable est exportée par (guix build-system meson). Elle implémente la procédure de construction des paquets qui utilisent Meson comme système de construction.

Elle ajoute à la fois Meson et Ninja à l’ensemble des entrées, et ils peuvent être modifiés avec les paramètres #:meson et #:ninja si requis. Le Meson par défaut est meson-for-build, qui est spécial parce qu’il ne nettoie pas le RUNPATH des binaires et les bibliothèques qu’il installe.

Ce système de construction est une extension de gnu-build-system, mais avec les phases suivantes modifiées pour Meson :

configure

La phase lance meson avec les drapeaux spécifiés dans #:configure-flags. Le drapeau --buildtype est toujours défini à debugoptimized à moins qu’autre chose ne soit spécifié dans #:build-type.

build

La phase lance ninja pour construire le paquet en parallèle par défaut, mais cela peut être changé avec #:parallel-build?.

check

La phase lance ninja avec la cible spécifiée dans #:test-target, qui est "test" par défaut.

install

La phase lance ninja install et ne peut pas être changée.

En dehors de cela, le système de construction ajoute aussi la phase suivante :

fix-runpath

Cette phase s’assure que tous les binaire peuvent trouver les bibliothèques dont ils ont besoin. Elle cherche les bibliothèques requises dans les sous-répertoires du paquet en construction et les ajoute au RUNPATH là où c’est nécessaire. Elle supprime aussi les références aux bibliothèques laissées là par la phase de construction par meson-for-build comme les dépendances des tests, qui ne sont pas vraiment requises pour le programme.

glib-or-gtk-wrap

Cette phase est la phase fournie par glib-or-gtk-build-system et n’est pas activée par défaut. Elle peut l’être avec #:glib-or-gtk?.

glib-or-gtk-compile-schemas

Cette phase est la phase fournie par glib-or-gtk-build-system et n’est pas activée par défaut. Elle peut l’être avec #:glib-or-gtk?.

Variable Scheme : linux-module-build-system

linux-module-build-system permet de construire des modules du noyau Linux.

Ce système de construction est une extension de gnu-build-system, mais avec les phases suivantes modifiées :

configure

Cette phase configure l’environnement pour que le Makefile du noyau Linux puisse être utilisé pour construire le module du noyau externe.

build

Cette phase utilise le Makefile du noyau Linux pour construire le module du noyau externe.

install

Cette phase utilise le Makefile du noyau Linux pour installer le module du noyau externe.

Il est possible et utile de spécifier le noyau Linux à utiliser pour construire le module (sous la forme arguments d’un paquet utilisant le linux-module-build-system, utilisez la clé #:linux pour le spécifier).

Variable Scheme : node-build-system

Cette variable est exportée par (guix build-system node). Elle implémente la procédure de compilation utilisée par Node.js, qui implémente une approximation de la commande npm install, suivie d’une commande npm test.

Le paquet Node.js utilisé pour interpréter les commandes npm peut être spécifié avec le paramètre #:node dont la valeur par défaut est node.

Enfin, pour les paquets qui n’ont pas besoin de choses sophistiquées, un système de construction « trivial » est disponible. Il est trivial dans le sens où il ne fournit en gros aucun support : il n’apporte pas de dépendance implicite, et n’a pas de notion de phase de construction.

Variable Scheme : trivial-build-system

Cette variable est exportée par (guix build-system trivial).

Ce système de construction requiert un argument #:builder. Cet argument doit être une expression Scheme qui construit la sortie du paquet — comme avec build-expression->derivation (voir build-expression->derivation).


Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.5 Phases de construction

Presque tous les systèmes de construction de paquets mettent en œuvre une notion de phase de construction : une séquence d’actions que le système de construction exécute, lorsque vous construisez le paquet, conduisant aux sous-produits installés dans le dépôt. Une exception notable est le trivial-build-system (voir Systèmes de construction) minimaliste.

Comme nous l’avons vu dans la section précédente, ces systèmes de construction fournissent une liste standard de phases. Pour gnu-build-system, les phases standard comprennent une phase unpack pour décompresser l’archive du code source, une phase configure pour exécuter ./configure, une phase build pour exécuter make, et (entre autres) une phase install pour exécuter make install ; voir Systèmes de construction, pour une vue plus détaillée de ces phases. De même, cmake-build-system hérite de ces phases, mais sa phase configure exécute cmake au lieu de ./configure. D’autres systèmes de compilation, tels que python-build-system, ont une liste de phases standard totalement différente. Tout ce code s’exécute côté construction : il est évalué lorsque vous construisez réellement le paquet, dans un processus de construction dédié engendré par le démon de construction (voir Invoquer guix-daemon).

Les phases de construction sont représentées sous forme de listes d’associations ou « alists » (voir Listes d’association dans Manuel de référence de GNU Guile) où chaque clé est un symbole pour le nom de la phase et la valeur associée est une procédure qui accepte un nombre arbitraire d’arguments. Par convention, ces procédures reçoivent des informations sur la construction sous la forme de paramètres nommés, qu’elles peuvent utiliser ou ignorer.

Par exemple, voici comment (guix build gnu-build-system) définit %standard-phases, la variable contenant sa liste de phases de construction17 :

;; Les phases de construction de "gnu-build-system".

(define* (unpack #:key source #:allow-other-keys)
  ;; Extrait l'archive des sources.
  (invoke "tar" "xvf" source))

(define* (configure #:key outputs #:allow-other-keys)
  ;; Exécute le script « configure ». Installe la sortie « out ».
  (let ((out (assoc-ref outputs "out")))
    (invoke "./configure"
            (string-append "--prefix=" out))))

(define* (build #:allow-other-keys)
  ;; Compile.
  (invoke "make"))

(define* (check #:key (test-target "check") (tests? #true)
                #:allow-other-keys)
  ;; Lance la suite de tests.
  (if tests?
      (invoke "make" test-target)
      (display "test suite not run\n")))

(define* (install #:allow-other-keys)
  ;; Installe les fichiers sous le préfixe spécifié à « configure ».
  (invoke "make" "install"))

(define %standard-phases
  ;; La liste des phases standard (un certain nombre d'entre elles sont omises
  ;; par souci de concision).  Chaque élément est une paire symbole/procédure.
  (list (cons 'unpack unpack)
        (cons 'configure configure)
        (cons 'build build)
        (cons 'check check)
        (cons 'install install)))

Cela montre comment %standard-phases est défini comme une liste de paires symbole/procédure (voir Pairs dans GNU Guile Reference Manual). La première paire associe le symbole unpack — un nom — à la procédure unpack ; la deuxième paire définit la phase configure de manière similaire, et ainsi de suite. Lors de la construction d’un paquet qui utilise gnu-build-system avec sa liste de phases par défaut, ces phases sont exécutées de manière séquentielle. Vous pouvez voir le nom de chaque phase commencée et terminée dans le journal de construction des paquets que vous construisez.

Examinons maintenant les procédures elles-mêmes. Chacune est définie par define* : #:key énumère les paramètres nommés que la procédure accepte, éventuellement avec une valeur par défaut, et #:allow-other-keys précise que les autres paramètres nommés sont ignorés (voir Optional Arguments dans GNU Guile Reference Manual).

La procédure unpack respecte le paramètre source, que le système de compilation utilise pour passer le nom de fichier de l’archive source (ou le répertoire cloné d’un système de contrôle de version), et elle ignore les autres paramètres. La phase configure ne s’intéresse qu’au paramètre outputs, une liste d’association des noms des sorties du paquet avec le nom de leur fichier du dépôt (voir Des paquets avec plusieurs résultats). Elle extrait le nom de fichier de out, la sortie par défaut, et le transmet à ./configure comme préfixe d’installation, ce qui signifie que make install copiera tous les fichiers vers ce répertoire (voir configuration and makefile conventions dans GNU Coding Standards). build et install ignorent tous leurs arguments. check prend en considération l’argument test-target, qui spécifie le nom de la cible du Makefile pour exécuter les tests ; il imprime un message et saute les tests lorsque tests? est faux.

La liste des phases utilisées pour un paquet particulier peut être modifiée avec le paramètre #:phases du système de construction. La modification de l’ensemble des phases de construction se résume à la création d’une nouvelle liste de phases basée sur la liste %standard-phases décrite ci-dessus. On peut faire cela à l’aide des procédures standards qui manipulent des listes d’associations telles que alist-delete (voir SRFI-1 Association Lists dans GNU Guile Reference Manual) ; cependant, il est plus pratique de le faire avec modify-phases (voir modify-phases).

Voici un exemple de définition de paquet qui supprime la phase configure de %standard-phases et insère une nouvelle phase avant la phase build, appelée set-prefix-in-makefile :

(define-public example
  (package
    (name "example")
    ;; les autres champs sont omis
    (build-system gnu-build-system)
    (arguments
     '(#:phases (modify-phases %standard-phases
                  (delete 'configure)
                  (add-before 'build 'set-prefix-in-makefile
                    (lambda* (#:key outputs #:allow-other-keys)
                      ;; Modifie le Makefile pour que sa variable
                      ;; 'PREFIX' pointe vers « out ».
                      (let ((out (assoc-ref outputs "out")))
                        (substitute* "Makefile"
                          (("PREFIX =.*")
                           (string-append "PREFIX = "
                                          out "\n")))
                        #true))))))))

La nouvelle phase insérée est écrite comme une procédure anonyme, introduite avec lambda* ; elle honore le paramètre outputs que nous avons vu auparavant. Voir Utilitaires de construction, pour en savoir plus sur les procédures auxiliaires utilisées par cette phase, et pour d’autres exemples de modify-phases.

Gardez à l’esprit que le code des phases de construction est évalué à la construction effective des paquets. Cela explique pourquoi toute l’expression modify-phases ci-dessus est citée (elle vient après ' ou apostrophe) : elle est mise de côté pour une exécution ultérieure. Voir G-Expressions, pour une explication de la mise en place du code et des strates de code concernées.


Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.6 Utilitaires de construction

Dès que vous commencerez à écrire des définitions de paquets non triviales (voir Définition des paquets) ou d’autres actions de compilation (voir G-Expressions), vous commencerez probablement à chercher des fonctions auxiliaires pour les actions « de type shell » — créer des répertoires, copier et supprimer des fichiers de manière récursive, manipuler les phases de compilation, etc. Le module (guix build utils) fournit de telles procédures utilitaires.

La plupart des systèmes de construction chargent (guix build utils) (voir Systèmes de construction). Ainsi, lorsque vous écrivez des phases de construction personnalisées pour vos définitions de paquets, vous pouvez généralement supposer que ces procédures sont disponibles.

Lorsque vous écrivez des G-expressions, vous pouvez importer (guix build utils) « côté construction » en utilisant with-imported-modules et ensuite le rendre disponible avec la forme use-modules (voir Using Guile Modules dans GNU Guile Reference Manual) :

(with-imported-modules '((guix build utils))  ;on l'importe
  (computed-file "empty-tree"
                 #~(begin
                     ;; On le rend disponible.
                     (use-modules (guix build utils))

                     ;; On utilise sa procédure « mkdir-p » sans souci.
                     (mkdir-p (string-append #$output "/a/b/c")))))

Le reste de cette section est la référence pour la plupart des procédures auxiliaires fournies par (guix build utils).

8.6.1 Traitement des noms de fichiers du dépôt

Cette section documente les procédures de traitement des noms de fichier du dépôt.

Procédure Scheme : %store-directory

Renvoie le nom de répertoire du dépôt.

Procédure Scheme : store-file-name? fichier

Renvoie vrai si fichier est dans le dépôt.

Procédure Scheme : strip-store-file-name fichier

Enlevez le /gnu/store et le hash de fichier, un nom de fichier du dépôt. Le résultat est généralement une chaîne "paquet-version".

Procédure Scheme : package-name->name+version nom

Si l’on passe nom, un nom de paquet comme "foo-0.9.1b", on obtient deux valeurs : "foo" et "0.9.1b". Lorsque la partie version est indisponible, nom et #f sont renvoyés. Le premier trait d’union suivi d’un chiffre est considéré comme introduisant la partie version.

8.6.2 Types de fichier

Les procédures ci-dessous portent sur les fichiers et les types de fichiers.

Procédure Scheme : directory-exists? dir

Renvoie #t si dir existe et est un répertoire.

Procédure Scheme : executable-file? fichier

Renvoie #t si fichier existe et est exécutable.

Renvoie #t si fichier est un lien symbolique (un « symlink »).

Procédure Scheme : elf-file? fichier
Procédure Scheme : ar-file? fichier
Procédure Scheme : gzip-file? fichier

Renvoie #t si fichier est, respectivement, un fichier ELF, une archive ar (telle qu’une bibliothèque statique .a), ou un fichier gzip.

Procédure Scheme : reset-gzip-timestamp fichier [#:keep-mtime? #t]

Si fichier est un fichier gzip, réinitialise son horodatage intégré (comme avec gzip --no-name) et renvoie vrai. Sinon, renvoie #f. Lorsque keep-mtime? est vrai, conserve la date de modification de fichier.

8.6.3 Manipulation de fichiers

Les procédures et macros suivantes permettent de créer, modifier et supprimer des fichiers. Elles offrent des fonctionnalités comparables à celles des utilitaires shell courants tels que mkdir -p, cp -r, rm -r et sed. Elles complètent l’interface de système de fichiers étendue, mais de bas niveau, de Guile (voir POSIX dans GNU Guile Reference Manual).

Syntaxe Scheme : with-directory-excursion répertoire corps

Exécute corps avec répertoire comme répertoire actuel du processus.

En gros, cette macro change le répertoire actuel en répertoire avant d’évaluer corps, en utilisant chdir. (voir Processus dans Manuel de référence de GNU Guile). Elle revient au répertoire initial à la sortie de la portée dynamique de corps, qu’il s’agisse d’un retour de procédure normal ou d’une sortie non locale telle qu’une exception.

Procédure Scheme : mkdir-p dir

Crée le répertoire dir et tous ses ancètres.

Procédure Scheme : install-file fichier répertoire

Crée répertoire s’il n’existe pas et y copie fichier sous le même nom.

Procédure Scheme : make-file-writable fichier

Rend fichier inscriptible pour son propriétaire.

Procédure Scheme : copy-recursively source destination [#:log (current-output-port)] [#:follow-symlinks? #f] [#:keep-mtime? #f]

Copie le répertoire source dans destination. Suivez les liens symboliques si follow-symlinks? est vrai ; sinon, conservez-les. Lorsque keep-mtime? est vrai, conservez les heures de modification des fichiers dans source sur celles de destination. Écrivez une sortie verbeuse sur le port log.

Procédure Scheme : delete-file-recursively dir [#:follow-mounts? #f]

Efface récursivement dir, comme rm -rf, sans les liens symboliques suivants. Ne suit pas non plus les points de montage, à moins que follow-mounts? ne soit vrai. Rapporte mais ignore les erreurs.

Syntaxe Scheme : substitute* fichier ((regexp match-var…) body…) …

Remplace regexp dans fichier par la chaîne renvoyée par body. body est évalué avec chaque match-var lié à la sous-expression de regexp positionnelle correspondante. Par exemple :

(substitute* file
  (("hello")
   "good morning\n")
  (("foo([a-z]+)bar(.*)$" all letters end)
   (string-append "baz" letter end)))

Ici, chaque fois qu’une ligne de fichier contient hello, elle est remplacée par good morning. Chaque fois qu’une ligne de fichier correspond à la deuxième regexp, all est lié à la correspondance complète, letters est lié à la première sous-expression, et end est lié à la dernière.

Lorsque l’une des match-var est _, aucune variable n’est liée à la sous-chaîne de correspondance associée.

Autrement, fichier peut être une liste de noms de fichier, auquel cas ils sont tous sujets aux substitutions.

Faites attention à l’utilisation du $ pour faire correspondre la fin d’une ligne ; à lui seul, il ne correspondra pas à la fin d’une nouvelle ligne.

8.6.4 Recherche de fichiers

Cette section documente les procédures pour chercher et filtrer des fichiers.

Procédure Scheme : file-name-predicate regexp

Renvoie un prédicat qui devient vrai lorsqu’on lui passe un nom de fichier dont le nom de base correspond à regexp.

Procédure Scheme : find-files dir [pred] [#:stat lstat] [#:directories? #f] [#:fail-on-error? #f]

Renvoie la liste des fichiers triés lexicographiquement sous dir pour lesquels pred renvoie « vrai ». Deux arguments sont passés à pred : le nom absolu du fichier et son tampon stat ; le prédicat par défaut renvoie toujours « vrai ». pred peut également être une expression régulière, auquel cas elle est équivalente à (file-name-predicate pred). stat est utilisé pour obtenir des informations sur les fichiers ; l’utilisation de lstat signifie que les liens symboliques ne sont pas suivis. Si directories? est vrai, alors les répertoires seront également inclus. Si fail-on-error? est vrai, il lance une exception en cas d’erreur.

Voici quelques exemples où nous supposons que le répertoire actuel est la racine de l’arborescence des sources de Guix :

;; Liste tous les fichiers normaux dans le répertoire actuel.
(find-files ".")
 ("./.dir-locals.el" "./.gitignore" )

;; Liste tous les fichiers .scm sous gnu/services.
(find-files "gnu/services" "\\.scm$")
 ("gnu/services/admin.scm" "gnu/services/audio.scm" )

;; Liste les fichiers ar dans le répertoire actuel.
(find-files "." (lambda (file stat) (ar-file? file)))
 ("./libformat.a" "./libstore.a" )
Procédure Scheme : which programme

Renvoie le nom complet du fichier pour programme tel qu’il se trouve dans $PATH, ou #f si programme n’a pas pu être trouvé.

8.6.5 Phases de construction

Le (guix build utils) contient également des outils permettant de manipuler les phases de construction telles qu’elles sont utilisées par les systèmes de construction (voir Systèmes de construction). Les phases de construction sont représentées sous forme de listes d’associations ou « alists » (voir Association Lists dans Manuel de référence de GNU Guile) où chaque clé est un symbole désignant la phase et où la valeur associée est une procédure (voir Phases de construction).

Le noyau Guile et le module (srfi srfi-1) fournissent tous deux des outils pour manipuler les alignements. Le module (guix build utils) complète ces outils avec des outils écrits en tenant compte des phases de construction.

Syntaxe Scheme : modify-phases phases clause

Modifie phases séquentiellement selon chaque clause, qui peut avoir l’une des formes suivantes :

(delete old-phase-name)
(replace old-phase-name new-phase)
(add-before old-phase-name new-phase-name new-phase)
(add-after old-phase-name new-phase-name new-phase)

Où chaque phase-name ci-dessus est une expression s’évaluant en un symbole, et new-phase une expression évaluant à une procédure.

L’exemple ci-dessous est tiré de la définition du paquet grep. Il ajoute une phase à exécuter après la phase install, appelée fix-egrep-and-fgrep. Cette phase est une procédure (lambda* pour les procédures anonymes) qui prend un paramètre nommé #:outputs et ignore les paramètres nommés supplémentaires (voir Optional Arguments dans GNU Guile Reference Manual, pour en savoir plus sur lambda* et les arguments optionnels et nommés). La phase utilise substitute* pour modifier les scripts egrep et fgrep installés afin qu’ils se réfèrent à grep par son nom de fichier absolu :

(modify-phases %standard-phases
  (add-after 'install 'fix-egrep-and-fgrep
    ;; Corrige 'egrep' et 'fgrep' pour exécuter 'grep' via son
    ;; nom de fichier absolu au lieu de le chercher dans $PATH.
    (lambda* (#:key outputs #:allow-other-keys)
      (let* ((out (assoc-ref outputs "out"))
             (bin (string-append out "/bin")))
        (substitute* (list (string-append bin "/egrep")
                           (string-append bin "/fgrep"))
          (("^exec grep")
           (string-append "exec " bin "/grep")))
        #t))))

Dans l’exemple ci-dessous, les phases sont modifiées de deux façons : la phase standard configure est supprimée, vraisemblablement parce que le paquet n’a pas de script configure ou quelque chose de similaire, et la phase par défaut install est remplacée par une phase qui copie manuellement les fichiers exécutables à installer :

(modify-phases %standard-phases
  (delete 'configure)      ;no 'configure' script
  (replace 'install
    (lambda* (#:key outputs #:allow-other-keys)
      ;; Le Makefile du paquet ne fournit pas de règle « install »
      ;; alors on le fait nous-mêmes.
      (let ((bin (string-append (assoc-ref outputs "out")
                                "/bin")))
        (install-file "footswitch" bin)
        (install-file "scythe" bin)
        #t))))

Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.7 Le dépôt

Conceptuellement, le dépôt est l’endroit où les dérivations qui ont bien été construites sont stockées — par défaut, /gnu/store. Les sous-répertoires dans le dépôt s’appellent des éléments du dépôt ou parfois des chemins du dépôt. Le dépôt a une base de données associée qui contient des informations comme les chemins du dépôt auxquels se réfèrent chaque chemin du dépôt et la liste des éléments du dépôt valides — les résultats d’une construction réussie. Cette base de données se trouve dans localstatedir/guix/dblocalstatedir est le répertoire d’états spécifié via --localstatedir à la configuration, typiquement /var.

C’est toujours le démon qui accède au dépôt pour le compte de ses clients (voir Invoquer guix-daemon). Pour manipuler le dépôt, les clients se connectent au démon par un socket Unix-domain, envoient une requête dessus et lisent le résultat — ce sont des appels de procédures distantes, ou RPC.

Remarque : Les utilisateurs ne doivent jamais modifier les fichiers dans /gnu/store directement. Cela entraînerait des incohérences et casserait l’hypothèse d’immutabilité du modèle fonctionnel de Guix (voir Introduction).

Voir guix gc --verify, pour des informations sur la manière de vérifier l’intégrité du dépôt et d’essayer de réparer des modifications accidentelles.

Le module (guix store) fournit des procédures pour se connecter au démon et pour effectuer des RPCs. Elles sont décrites plus bas. Par défaut, open-connection, et donc toutes les commandes guix se connectent au démon local ou à l’URI spécifiée par la variable d’environnement GUIX_DAEMON_SOCKET.

Variable d'environnement : GUIX_DAEMON_SOCKET

Lorsqu’elle est initialisée, la valeur de cette variable devrait être un nom de fichier ou une URI qui désigne l’extrémité du démon. Lorsque c’est un nom de fichier, il dénote un socket Unix-domain où se connecter. En plus des noms de fichiers, les schémas d’URI supportés sont :

file
unix

Pour les sockets Unix-domain. file:///var/guix/daemon-socket/socket est équivalent à /var/guix/daemon-socket/socket.

guix

Ces URI dénotent des connexions par TCP/IP, sans chiffrement ni authentification de l’hôte distant. L’URI doit spécifier le nom d’hôte et éventuellement un numéro de port (par défaut 44146) :

guix://master.guix.example.org:1234

Ce paramétrage est adapté aux réseaux locaux, comme dans le cas de grappes de serveurs, où seuls des noms de confiance peuvent se connecter au démon de construction sur master.guix.example.org.

L’option --listen de guix-daemon peut être utilisé pour lui dire d’écouter les connexions TCP (voir --listen).

ssh

These URIs allow you to connect to a remote daemon over SSH. This feature requires Guile-SSH (voir Prérequis) and a working guile binary in PATH on the destination machine. It supports public key and GSSAPI authentication. A typical URL might look like this:

ssh://charlie@guix.example.org:22

Comme pour guix copy, les fichiers de configuration du client OpenSSH sont respectés (voir Invoquer guix copy).

Des schémas d’URI supplémentaires pourraient être supportés dans le futur.

Remarque : La capacité de se connecter à un démon de construction distant est considéré comme expérimental à la version 1.2.0. Contactez-nous pour partager vos problèmes ou des suggestions que vous pourriez avoir (voir Contribuer).

Procédure Scheme : open-connection [uri] [#:reserve-space? #t]

Se connecte au démon à travers le socket Unix-domain à uri (une chaîne de caractères). Lorsque reserve-space? est vrai, cela demande de réserver un peu de place supplémentaire sur le système de fichiers pour que le ramasse-miette puisse opérer au cas où le disque serait plein. Renvoie un objet serveur.

file prend par défaut la valeur %default-socket-path, qui est l’emplacement normal compte tenu des options qui ont été passées à configure.

Procédure Scheme : close-connection server

Ferme la connexion au serveur.

Variable Scheme : current-build-output-port

Cette variable est liée à un paramètre SRFI-39, qui se réfère au port où les journaux de construction et d’erreur envoyés par le démon devraient être écrits.

Les procédures qui font des RPC prennent toutes un objet serveur comme premier argument.

Procédure Scheme : valid-path? server path

Renvoie #t lorsque path désigne un élément valide du dépôt et #f sinon (un élément invalide peut exister sur le disque mais être toujours invalide, par exemple parce qu’il est le résultat d’une construction avortée ou échouée).

Une condition &store-protocol-error est levée si path n’est pas préfixée par le répertoire du dépôt (/gnu/store).

Procédure Scheme : add-text-to-store server name text [references]

Ajoute text dans le fichier name dans le dépôt et renvoie son chemin. references est la liste des chemins du dépôt référencés par le chemin du dépôt qui en résulte.

Procédure Scheme : build-derivations store derivations

[mode] Construit derivations, une liste d’objets <derivation>, de noms de fichiers .drv, ou de paires dérivation/sortie, en utilisant le mode(build-mode normal) spécifié par défaut.

Remarque que le module (guix monads) fournit une monade ainsi que des version monadiques des procédures précédentes, avec le but de rendre plus facile de travailler avec le code qui accède au dépôt (voir La monade du dépôt).

Cette section est actuellement incomplète.


Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.8 Dérivations

Les actions de construction à bas-niveau et l’environnement dans lequel elles sont effectuées sont représentés par des dérivations. Une dérivation contient cet ensemble d’informations :

Les dérivations permettent aux client du démon de communiquer des actions de construction dans le dépôt. Elles existent sous deux formes : en tant que représentation en mémoire, à la fois côté client et démon, et en tant que fichiers dans le dépôt dont le nom finit par .drv — on dit que ce sont des chemins de dérivations. Les chemins de dérivations peuvent être passés à la procédure build-derivations pour effectuer les actions de construction qu’ils prescrivent (voir Le dépôt).

Des opérations comme le téléchargement de fichiers et la récupération de sources gérés par un logiciel de contrôle de version pour lesquels le hash du contenu est connu à l’avance sont modélisés par des dérivations à sortie fixe. Contrairement aux dérivation habituelles, les sorties d’une dérivation à sortie fixe sont indépendantes de ses entrées — p.ex. un code source téléchargé produit le même résultat quelque soit la méthode de téléchargement utilisée.

Les sorties des dérivations — c.-à-d. les résultats de la construction — ont un ensemble de références, comme le rapporte le RPC references ou la commande guix gc --references (voir Invoquer guix gc). Les références sont l’ensemble des dépendances à l’exécution des résultats de la construction. Les références sont un sous-ensemble des entrées de la dérivation ; ce sous-ensemble est automatiquement calculé par le démon de construction en scannant tous les fichiers dans les sorties.

Le module (guix derivations) fournit une représentation des dérivations comme des objets Scheme, avec des procédures pour créer et manipuler des dérivations. La primitive de plus bas-niveau pour créer une dérivation est la procédure derivation :

Procédure Scheme : derivation store name builder args [#:outputs '("out")] [#:hash #f] [#:hash-algo #f] [#:recursive? #f] [#:inputs '()] [#:env-vars '()] [#:system (%current-system)] [#:references-graphs #f] [#:allowed-references #f] [#:disallowed-references #f] [#:leaked-env-vars #f] [#:local-build? #f] [#:substitutable? #t] [#:properties '()]

Construit une dérivation avec les arguments donnés et renvoie l’objet <derivation> obtenu.

Lorsque hash et hash-algo sont donnés, une dérivation à sortie fixe est créée — c.-à-d. une dérivation dont le résultat est connu à l’avance, comme dans le cas du téléchargement d’un fichier. Si, en plus, recursive? est vrai, alors la sortie fixe peut être un fichier exécutable ou un répertoire et hash doit être le hash d’une archive contenant la sortie.

Lorsque references-graphs est vrai, il doit s’agir d’une liste de paires de noms de fichiers et de chemins du dépôt. Dans ce cas, le graphe des références de chaque chemin du dépôt est exporté dans l’environnement de construction dans le fichier correspondant, dans un simple format texte.

Lorsque allowed-references est vrai, il doit s’agir d’une liste d’éléments du dépôt ou de sorties auxquelles la sortie de la dérivations peut faire référence. De même, disallowed-references, si vrai, doit être une liste de choses que la sortie ne doit pas référencer.

Lorsque leaked-env-vars est vrai, il doit s’agir d’une liste de chaînes de caractères qui désignent les variables d’environnements qui peuvent « fuiter » de l’environnement du démon dans l’environnement de construction. Ce n’est possible que pour les dérivations à sortie fixe — c.-à-d. lorsque hash est vrai. L’utilisation principale est de permettre à des variables comme http_proxy d’être passées aux dérivations qui téléchargent des fichiers.

Lorsque local-build? est vrai, déclare que la dérivation n’est pas un bon candidat pour le déchargement et devrait plutôt être construit localement (voir Réglages du délestage du démon). C’est le cas des petites dérivations où le coût du transfert de données est plus important que les bénéfices.

Lorsque que substitutable? est faux, déclare que les substituts de la sortie de la dérivation ne devraient pas être utilisés (voir Substituts). Cela est utile par exemple pour construire des paquets qui utilisent des détails du jeu d’instruction du CPU hôte.

properties doit être une liste d’association décrivant les « propriétés » de la dérivation. Elle est gardée telle-quelle, sans être interprétée, dans la dérivation.

Voici un exemple avec un script shell comme constructeur, en supposant que store est une connexion ouverte au démon et bash pointe vers un exécutable Bash dans le dépôt :

(use-modules (guix utils)
             (guix store)
             (guix derivations))

(let ((builder   ; ajoute le script Bash au dépôt
        (add-text-to-store store "my-builder.sh"
                           "echo hello world > $out\n" '())))
  (derivation store "foo"
              bash `("-e" ,builder)
              #:inputs `((,bash) (,builder))
              #:env-vars '(("HOME" . "/homeless"))))
 #<derivation /gnu/store/…-foo.drv => /gnu/store/…-foo>

Comme on pourrait s’en douter, cette primitive est difficile à utiliser directement. Une meilleure approche est d’écrire les scripts de construction en Scheme, bien sur ! Le mieux à faire pour cela est d’écrire le code de construction comme une « G-expression » et de la passer à gexp->derivation. Pour plus d’informations, voir G-Expressions.

Il fut un temps où gexp->derivation n’existait pas et où construire une dérivation donc le code de construction était écrit en Scheme se faisait avec build-expression->derivation, documenté plus bas. Cette procédure est maintenant obsolète, remplacée par gexp->derivation qui est meilleure.

Procédure Scheme : build-expression->derivation store name exp [#:system (%current-system)] [#:inputs '()] [#:outputs '("out")] [#:hash #f] [#:hash-algo #f] [#:recursive? #f] [#:env-vars '()] [#:modules '()] [#:references-graphs #f] [#:allowed-references #f] [#:disallowed-references #f] [#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f]

Renvoie une dérivation qui exécute l’expression Scheme exp comme un constructeur pour la dérivation name. inputs doit être une liste de tuples (name drv-path sub-drv) ; lorsque sub-drv est omis, "out" est utilisé. modules est une liste de noms de modules Guile du chemin de recherche actuel qui seront copiés dans le dépôt, compilés et rendus disponibles dans le chemin de chargement pendant l’exécution de exp — p. ex. ((guix build utils) (guix build gnu-build-system)).

exp est évaluée dans une environnement où %outputs est lié à une liste de paires de sortie/chemin, et où %build-inputs est lié à une liste de paires de chaînes de caractères et de chemin de sortie construite à partir de inputs. Éventuellement, env-vars est une liste de paires de chaînes de caractères spécifiant le nom et la valeur de variables d’environnement visibles pour le constructeur. Le constructeur termine en passant le résultat de exp à exit ; ainsi, lorsque exp renvoie #f, la construction est considérée en échec.

exp est construite avec guile-for-build (une dérivation). Lorsque guile-for-build est omis où est #f, la valeur du fluide %guile-for-build est utilisée à la place.

Voir la procédure derivation pour la signification de references-graph, allowed-references, disallowed-references, local-build? et substitutable?.

Voici un exemple de dérivation à sortie unique qui crée un répertoire avec un fichier :

(let ((builder '(let ((out (assoc-ref %outputs "out")))
                  (mkdir out)    ; create /gnu/store/…-goo
                  (call-with-output-file (string-append out "/test")
                    (lambda (p)
                      (display '(hello guix) p))))))
  (build-expression->derivation store "goo" builder))

 #<derivation /gnu/store/…-goo.drv => …>

Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.9 La monade du dépôt

Les procédures qui travaillent sur le dépôt décrites dans les sections précédentes prennent toutes une connexion ouverte au démon de construction comme premier argument. Bien que le modèle sous-jacent soit fonctionnel, elles ont soit des effets de bord, soit dépendent de l’état actuel du dépôt.

Le premier point est embêtant : on doit se balader avec la connexion au démon dans toutes ces fonctions, ce qui rend impossible le fait de composer des fonctions qui ne prennent pas ce paramètre avec des fonctions qui le prennent. Le deuxième point est problématique : comme les opérations sur le dépôt ont des effets de bord ou dépendent d’états externes, elles doivent être enchaînés correctement.

C’est là que le module (guix monads) arrive à la rescousse. Ce module fournit un cadre pour travailler avec des monads, en particulier une monade très utile pour notre usage, la monade du dépôt. Les monades sont des constructions qui permettent deux choses : associer un « contexte » avec une valeur (dans notre cas, le contexte est le dépôt) et construire une séquence de calculs (ici les calculs comprennent des accès au dépôt). Les valeurs dans une monade — les valeurs qui contiennent ce contexte supplémentaire — sont appelées des valeurs monadiques ; les procédures qui renvoient ce genre de valeur sont appelées des procédures monadiques.

Considérez cette procédure « normale » :

(define (sh-symlink store)
  ;; Renvoie une dérivation qui crée un lien symbolique vers l'exécutable « bash ».
  (let* ((drv (package-derivation store bash))
         (out (derivation->output-path drv))
         (sh  (string-append out "/bin/bash")))
    (build-expression->derivation store "sh"
                                  `(symlink ,sh %output))))

En utilisant (guix monads) et (guix gexp), on peut la réécrire en une fonction monadique :

(define (sh-symlink)
  ;; Pareil, mais renvoie une valeur monadique.
  (mlet %store-monad ((drv (package->derivation bash)))
    (gexp->derivation "sh"
                      #~(symlink (string-append #$drv "/bin/bash")
                                 #$output))))

Il y a plusieurs choses à remarquer avec cette deuxième version : le paramètre store est maintenant implicitement « enfilé » dans les appels aux procédures monadiques package->derivation et gexp->derivation, et la valeur monadique renvoyée par package->derivation est liée avec mlet plutôt qu’avec un simple let.

Il se trouve que l’appel à package->derivation peut même être omis puisqu’il aura lieu implicitement, comme nous le verrons plus tard (voir G-Expressions) :

(define (sh-symlink)
  (gexp->derivation "sh"
                    #~(symlink (string-append #$bash "/bin/bash")
                               #$output)))

L’appel à la procédure monadique sh-symlink n’a aucun effet. Comme on pourrait le dire, « on sort d’une monade comme de la monarchie : en l’exécutant »18. Donc, pour sortir de la monade et obtenir l’effet escompté, on doit utiliser run-with-store :

(run-with-store (open-connection) (sh-symlink))
 /gnu/store/...-sh-symlink

Remarquez que le module (guix monad-repl) étend la console Guile avec de nouvelles « méta-commandes » pour rendre plus facile la manipulation de procédures monadiques : run-in-store et enter-store-monad. La première est utilisée pour « lancer » une seule valeur monadique à travers le dépôt :

scheme@(guile-user)> ,run-in-store (package->derivation hello)
$1 = #<derivation /gnu/store/…-hello-2.9.drv => …>

La deuxième entre dans une console récursive, où toutes les valeurs de retour sont automatiquement lancées à travers le dépôt :

scheme@(guile-user)> ,enter-store-monad
store-monad@(guile-user) [1]> (package->derivation hello)
$2 = #<derivation /gnu/store/…-hello-2.9.drv => …>
store-monad@(guile-user) [1]> (text-file "foo" "Hello!")
$3 = "/gnu/store/…-foo"
store-monad@(guile-user) [1]> ,q
scheme@(guile-user)>

Remarquez qu’on ne peut pas renvoyer de valeur non monadique dans la console store-monad.

Les formes syntaxiques principales pour utiliser des monades en général sont disponibles dans le module (guix monads) et sont décrites ci-dessous.

Syntaxe Scheme : with-monad monad body ...

Évalue n’importe quelle forme >>= ou return dans body comme une monad.

Syntaxe Scheme : return val

Renvoie une valeur monadique qui encapsule val.

Syntaxe Scheme : >>= mval mproc ...

Lie une valeur monadique mval, en passant son « contenu » aux procédures monadiques mproc19. Il peut y avoir une ou plusieurs mproc, comme dans cet exemple :

(run-with-state
    (with-monad %state-monad
      (>>= (return 1)
           (lambda (x) (return (+ 1 x)))
           (lambda (x) (return (* 2 x)))))
  'some-state)

 4
 some-state
Syntaxe Scheme : mlet monad ((var mval) ...) body ...
Syntaxe Scheme : mlet* monad ((var mval) ...) body ...

Lie les variables var aux valeurs monadiques mval dans body, une séquence d’expressions. Comme avec l’opérateur de liaison, on peut réfléchir comme si on « ouvrait » la valeur non-monadique « contenue » dans mval et comme si on faisait en sorte que var se réfère à cette valeur pure, non-monadique, dans la portée de body. La forme (var -> val) lie var à la valeur « normale » val, comme let. L’opération de liaison a lieu en séquence de la gauche vers la droite. La dernière expression de body doit être une expression monadique et son résultat deviendra le résultat de mlet ou mlet* lorsque lancé dans la monad.

mlet* est à mlet ce que let* est à let (voir Local Bindings dans GNU Guile Reference Manual).

Système Scheme : mbegin monad mexp ...

Lie mexp et les expressions monadiques suivantes en séquence, et renvoie le résultat de la dernière expression. Chaque expression dans la séquence doit être une expression monadique.

Cette procédure est similaire à mlet, sauf que les valeurs de retour des expressions monadiques sont ignorées. Dans ce sens, elle est analogue à begin, mais appliqué à des expressions monadiques.

Système Scheme : mwhen condition mexp0 mexp* ...

Lorsque la condition est vraie, évalue la séquence des expressions monadiques mexp0..mexp* comme dans un mbegin. Lorsque la condition est fausse, renvoie *unspecified* dans la monade actuelle. Chaque expression dans la séquence doit être une expression monadique.

Système Scheme : munless condition mexp0 mexp* ...

Lorsque la condition est fausse, évalue la séquence des expressions monadiques mexp0..mexp* comme dans un mbegin. Lorsque la condition est vraie, renvoie *unspecified* dans la monade actuelle. Chaque expression dans la séquence doit être une expression monadique.

Le module (guix monads) fournit la monade d’état qui permet à une valeur supplémentaire — l’état — d’être enfilée à travers les appels de procédures.

Variable Scheme : %state-monad

La monade d’état. les procédure dans la monade d’état peuvent accéder et modifier l’état qui est enfilé.

Considérez l’exemple ci-dessous. La procédure square renvoie une valeur dans la monade d’état. Elle renvoie le carré de son argument, mais incrémente aussi la valeur actuelle de l’état :

(define (square x)
  (mlet %state-monad ((count (current-state)))
    (mbegin %state-monad
      (set-current-state (+ 1 count))
      (return (* x x)))))

(run-with-state (sequence %state-monad (map square (iota 3))) 0)
 (0 1 4)
 3

Lorsque c’est « lancé » à travers %state-monad, nous obtenons cette valeur d’état supplémentaire, qui est le nombre d’appels au square.

Procédure monadique : current-state

Renvoie l’état actuel dans une valeur monadique.

Procédure monadique : set-current-state value

Initialise l’état actuel à value et renvoie l’état précédent dans une valeur monadique.

Procédure monadique : state-push value

Pousse value sur l’état actuel, qui est supposé être une liste, et renvoie l’état précédent dans une valeur monadique.

Procédure monadique : state-pop

Récupère (pop) une valeur dans l’état actuel et la renvoie comme une valeur monadique. L’état est supposé être une liste.

Procédure Scheme : run-with-state mval [state]

Lance la valeur monadique mval avec state comme valeur initiale. Renvoie deux valeurs : la valeur du résultat et l’état du résultat.

L’interface principale avec la monade du dépôt, fournit par le module (guix store), est la suivante.

Variable Scheme : %store-monad

La monade du dépôt — un alias pour %state-monad.

Les valeurs dans la monade du dépôt encapsulent les accès vers le dépôt. Lorsque son effet est nécessaire, une valeur de la monade du dépôt doit être « évaluée » en la passant à la procédure run-with-store (voir ci-dessous).

Procédure Scheme : run-with-store store mval [#:guile-for-build] [#:system (%current-system)]

Lance mval, une valeur monadique dans la monade du dépôt, dans store, une connexion ouvert au dépôt.

Procédure monadique : text-file name text [references]

Renvoie une valeur monadique correspondant au nom de fichier dans le dépôt du fichier contenant text, une chaîne de caractères. references est une liste d’éléments du dépôt auxquels le fichier texte en résultat se réfère ; c’est la liste vide par défaut.

Procédure monadique : binary-file name data [references]

Renvoie une valeur monadique correspondant au nom de fichier absolu dans le dépôt du fichier contenant data, un vecteur d’octets. references est une liste d’éléments du dépôt auxquels le fichier binaire en résultat se réfère ; c’est la liste vide par défaut.

Procédure monadique : interned-file file [name] [#:recursive? #t] [#:select? (const #t)]

Renvoie le nom de file une fois ajouté au dépôt. Utilise name comme nom dans le dépôt ou le nom de fichier de file si name est omis.

Lorsque recursive? est vraie, le contenu de file est ajouté récursivement ; si file désigne un fichier simple et que recursive? est vrai, son contenu est ajouté et ses bits de permissions sont préservés.

Lorsque recursive? est vraie, appelle (select? file stat) pour chaque répertoire où file est le nom de fichier absolu de l’entrée et stat est le résultat de lstat ; à l’exception des entrées pour lesquelles select? ne renvoie pas vrai.

L’exemple ci-dessous ajoute un fichier au dépôt, sous deux noms différents :

(run-with-store (open-connection)
  (mlet %store-monad ((a (interned-file "README"))
                      (b (interned-file "README" "LEGU-MIN")))
    (return (list a b))))

 ("/gnu/store/rwm…-README" "/gnu/store/44i…-LEGU-MIN")

Le module (guix packages) exporte les procédures monadiques liées aux paquets suivantes :

Procédure monadique : package-file package [file] [#:system (%current-system)] [#:target #f] [#:output "out"]

Renvoie une valeur monadique qui contient le nom de fichier absolu de file dans le répertoire output de package. Lorsque file est omis, renvoie le nom du répertoire output de package. Lorsque target est vrai, l’utilise comme un triplet de cible pour la compilation croisée.

Notez que cette procédure ne permet pas de construire package. Ainsi, le résultat peut ou non désigner un fichier existant. Nous vous recommandons de ne pas utiliser cette procédure si vous ne savez pas ce que vous faites.

Procédure monadique : package->derivation package [system]
Procédure monadique : package->cross-derivation package target [system]

Version monadique de package-derivation et package-cross-derivation (voir Définition des paquets).


Suivant: , Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.10 G-Expressions

On a donc des « dérivations » qui représentent une séquence d’actions de construction à effectuer pour produire un élément du dépôt (voir Dérivations). Ces actions de construction sont effectuées lorsqu’on demande au démon de construire effectivement les dérivations ; elles sont lancées par le démon dans un conteneur (voir Invoquer guix-daemon).

Ça ne devrait pas vous surprendre, mais nous aimons écrire ces actions de construction en Scheme. Lorsqu’on fait ça, on fini avec deux strates de code Scheme20 : le « code hôte » — le code qui définit les paquets, parle au démon, etc. — et le « code côté construction » — le code qui effectue effectivement les actions de construction, comme créer des répertoires, invoquer make, etc. (voir Phases de construction).

Pour décrire une dérivation et ses actions de construction, on a typiquement besoin d’intégrer le code de construction dans le code hôte. Ça revient à manipuler le code de construction comme de la donnée, et l’homoiconicité de Scheme — le code a une représentation directe en tant que donnée — est très utile pour cela. Mais on a besoin de plus que le mécanisme de quasiquote en Scheme pour construire des expressions de construction.

Le module (guix gexp) implémente les G-expressions, une forme de S-expression adaptée aux expressions de construction. Les G-expression, ou gexps, consistent en gros en trois formes syntaxiques : gexp, ungexp et ungexp-splicing (ou plus simplement : #~, #$ et #$@), qui sont comparable à quasiquote, unquote et unquote-splicing respectivement (voir quasiquote dans GNU Guile Reference Manual). Cependant il y a des différences majeures :

Ce mécanisme n’est pas limité aux paquets et aux objets de dérivation : Des compilateurs capables d’ « abaisser » d’autres objets de haut niveau vers des dérivations ou des fichiers dans le dépôt peuvent être définis, de sorte que ces objets peuvent également être insérés dans des gexps. Par exemple, un type utile d’objets de haut niveau pouvant être insérés dans un gexp est celui des « objets de type fichier », qui permettent d’ajouter facilement des fichiers au dépôt et d’y faire référence dans des dérivations et autres (voir local-file et plain-file ci-dessous).

Pour illustrer cette idée, voici un exemple de gexp :

(define build-exp
  #~(begin
      (mkdir #$output)
      (chdir #$output)
      (symlink (string-append #$coreutils "/bin/ls")
               "list-files")))

Cette gexp peut être passée à gexp->derivation ; on obtient une dérivation qui construit une répertoire contenant exactement un lien symbolique à /gnu/store/…-coreutils-8.22/bin/ls :

(gexp->derivation "the-thing" build-exp)

Comme on pourrait s’y attendre, la chaîne "/gnu/store/…-coreutils-8.22" est substituée à la place de la référence au paquet coreutils dans le code de construction final, et coreutils est automatiquement devenu une entrée de la dérivation. De même, #$output (équivalent à (ungexp output)) est remplacé par une chaîne de caractères contenant le nom du répertoire de la sortie de la dérivation.

Dans le contexte d’une compilation croisée, il est utile de distinguer entre des références à la construction native d’un paquet — qui peut être lancé par l’hôte — et des références à la construction croisée d’un paquet. Pour cela, #+ joue le même rôle que #$, mais référence une construction native d’un paquet :

(gexp->derivation "vi"
   #~(begin
       (mkdir #$output)
       (mkdir (string-append #$output "/bin"))
       (system* (string-append #+coreutils "/bin/ln")
                "-s"
                (string-append #$emacs "/bin/emacs")
                (string-append #$output "/bin/vi")))
   #:target "aarch64-linux-gnu")

Dans l’exemple ci-dessus, la construction native de coreutils est utilisée, pour que ln puisse effectivement être lancé sur l’hôte ; mais ensuite la construction croisée d’emacs est utilisée.

Une autre fonctionnalité, ce sont les modules importés : parfois vous voudriez pouvoir utiliser certains modules Guile de « l’environnement hôte » dans la gexp, donc ces modules devraient être importés dans « l’environnement de construction ». La forme with-imported-modules vous permet d’exprimer ça :

(let ((build (with-imported-modules '((guix build utils))
               #~(begin
                   (use-modules (guix build utils))
                   (mkdir-p (string-append #$output "/bin"))))))
  (gexp->derivation "empty-dir"
                    #~(begin
                        #$build
                        (display "success!\n")
                        #t)))

Dans cet exemple, le module (guix build utils) est automatiquement récupéré dans l’environnement de construction isolé de notre gexp, pour que (use-modules (guix build utils)) fonctionne comme on s’y attendrait.

Typiquement, vous voudriez que la closure complète du module soit importé — c.-à-d. le module lui-même et tous les modules dont il dépend — plutôt que seulement le module ; sinon, une tentative de chargement du module échouera à cause des modules dépendants manquants. La procédure source-module-closure calcule la closure d’un module en cherchant dans ses en-têtes sources, ce qui est pratique dans ce cas :

(use-modules (guix modules))   ;pour 'source-module-closure'

(with-imported-modules (source-module-closure
                         '((guix build utils)
                           (gnu build vm)))
  (gexp->derivation "something-with-vms"
                    #~(begin
                        (use-modules (guix build utils)
                                     (gnu build vm))
                        )))

Dans la même idée, parfois vous pouvez souhaiter importer non seulement des modules en Scheme pur, mais aussi des « extensions » comme des liaisons Guile de bibliothèques C ou d’autres paquet « complets ». Disons que vous voulez utiliser le paquet guile-json du côté de la construction, voici comme procéder :

(use-modules (gnu packages guile))  ;pour 'guile-json'

(with-extensions (list guile-json)
  (gexp->derivation "something-with-json"
                    #~(begin
                        (use-modules (json))
                        )))

La forme syntaxique pour construire des gexps est résumée ci-dessous.

Syntaxe Scheme : #~exp
Syntaxe Scheme : (gexp exp)

Renvoie une G-expression contenant exp. exp peut contenir une ou plusieurs de ces formes :

#$obj
(ungexp obj)

Introduit une référence à obj. obj peut être d’un des types supportés, par exemple un paquet ou une dérivation, auquel cas la forme ungexp est remplacée par le nom de fichier de sa sortie — p. ex. "/gnu/store/…-coreutils-8.22.

Si boj est une liste, elle est traversée et les références aux objets supportés sont substitués de manière similaire.

Si obj est une autre gexp, son contenu est inséré et ses dépendances sont ajoutées à celle de la gexp qui l’entoure.

Si obj est un autre type d’objet, il est inséré tel quel.

#$obj:output
(ungexp obj output)

Cette forme est similaire à la précédente, mais se réfère explicitement à la sortie output de l’objet obj — c’est utile lorsque obj produit plusieurs sorties (voir Des paquets avec plusieurs résultats).

#+obj
#+obj:output
(ungexp-native obj)
(ungexp-native obj output)

Comme ungexp, mais produit une référence à la construction native de obj lorsqu’elle est utilisée dans une compilation croisée.

#$output[:output]
(ungexp output [output])

Insère une référence à la sortie output de la dérivation, ou à la sortie principale lorsque output est omis.

Cela ne fait du sens que pour les gexps passées à gexp->derivation.

#$@lst
(ungexp-splicing lst)

Comme au dessus, mais recolle (splice) le contenu de lst dans la liste qui la contient.

#+@lst
(ungexp-native-splicing lst)

Comme au dessus, mais se réfère à la construction native des objets listés dans lst.

Les G-expressions créées par gexp ou #~ sont des objets d’exécution du type gexp? (voir ci-dessous).

Syntaxe Scheme : with-imported-modules modules body

Marque les gexps définies dans body… comme requérant modules dans leur environnement d’exécution.

Chaque élément dans module peut être le nom d’un module, comme (guix build utils) ou le nom d’un module suivi d’une flèche, suivie d’un objet simili-fichier :

`((guix build utils)
  (guix gcrypt)
  ((guix config) => ,(scheme-file "config.scm"
                                  #~(define-module ))))

Dans l’exemple au dessus, les deux premiers modules sont récupérés dans le chemin de recherche, et le dernier est créé à partir d’un objet simili-fichier.

Cette forme a une portée lexicale : elle a un effet sur les gexp directement définies dans body…, mais pas sur celles définies dans des procédures appelées par body….

Syntaxe Scheme : with-extensions extensions body

Marque les gexps définies dans body… comme requérant extensions dans leur environnement de construction et d’exécution. extensions est typiquement une liste d’objets paquets comme définis dans le module (gnu packages guile).

Concrètement, les paquets listés dans extensions sont ajoutés au chemin de chargement lors de la compilation des modules importés dans body… ; ils sont aussi ajoutés au chemin de chargement de la gexp renvoyée par body….

Procédure Scheme : gexp? obj

Renvoie #t si obj est une G-expression.

Les G-expressions sont conçues pour être écrites sur le disque, soit en tant que code pour construire une dérivation, soit en tant que fichier normal dans le dépôt. Les procédures monadiques suivantes vous permettent de faire cela (voir La monade du dépôt, pour plus d’information sur les monads).

Procédure monadique : gexp->derivation name exp [#:system (%current-system)] [#:target #f] [#:graft ? #t] [#:hash #f] [#:hash-algo #f] [#:recursive ? #f] [#:env-vars '()] [#:modules '()] [#:module-path %load-path] [#:effective-version "2. 2"] [#:references-graphs #f] [#:allowed-references #f] [#:disallowed-references #f] [#:leaked-env-vars #f] [#:script-name (string-append name "-builder")] [#:deprecation-warnings #f] [#:local-build ? #f] [#:substituable ? #t] [#:properties '()] [#:guile-for-build #f]

Renvoie une dérivation name qui exécute exp (un gexp) avec guile-for-build (une dérivation) sur system ; exp est stocké dans un fichier appelé script-name. Lorsque target est vrai, il est utilisé comme le triplet cible de compilation croisée pour les paquets auxquels exp fait référence.

modules est devenu obsolète en faveur de with-imported-modules. Sa signification est de rendre modules disponibles dans le contexte d’évaluation de exp ; modules est une liste de noms de modules Guile qui sont cherchés dans module-path pour les copier dans le dépôt, les compiler et les rendre disponibles dans le chemin de chargement pendant l’exécution de exp — p. ex. ((guix build utils) (guix build gnu-build-system)).

effective-version détermine la chaîne à utiliser lors d’ajout d’extensions de exp (voir with-extensions) au chemin de recherche — p. ex. "2.2".

graft? détermine si les paquets référencés par exp devraient être greffés si possible.

Lorsque references-graphs est vrai, il doit s’agir d’une liste de tuples de la forme suivante :

(file-name package)
(file-name package output)
(file-name derivation)
(file-name derivation output)
(file-name store-item)

La partie droite des éléments de references-graphs est automatiquement transformée en une entrée du processus de construction exp. Dans l’environnement de construction, chaque file-name contient le graphe des références de l’élément correspondant, dans un format texte simple.

allowed-references doit soit être #f, soit une liste de noms de sorties ou de paquets. Dans ce dernier cas, la liste dénote les éléments du dépôt auxquels le résultat a le droit de faire référence. Toute référence à un autre élément du dépôt conduira à une erreur à la construction. Comme pour disallowed-references, qui peut lister des éléments qui ne doivent pas être référencés par les sorties.

deprecation-warnings détermine s’il faut afficher les avertissement d’obsolescence à la compilation de modules. Il peut valoir #f, t ou 'detailed.

Les autres arguments sont les mêmes que pour derivation (voir Dérivations).

Les procédures local-file, plain-file, computed-file, program-file et scheme-file ci-dessous renvoient des objets simili-fichiers. C’est-à-dire, lorsqu’ils sont unquotés dans une G-expression, ces objets donnent un fichier dans le dépôt. Considérez cette G-expression :

#~(system* #$(file-append glibc "/sbin/nscd") "-f"
           #$(local-file "/tmp/my-nscd.conf"))

Ici, l’effet est « d’internaliser » /tmp/my-nscd.conf en le copiant dans le dépôt. Une fois étendu, par exemple via gexp->derivation, la G-expression se réfère à cette copie dans /gnu/store ; ainsi, modifier ou supprimer le fichier dans /tmp n’a aucun effet sur ce que fait la G-expression. plain-file peut être utilisé de la même manière ; elle est seulement différente par le fait que le contenu du fichier est passé directement par une chaîne de caractères.

Procédure Scheme : local-file file [name] [#:recursive ? #f] [#:select ? (const #t)]

Renvoie un objet représentant le fichier local file à ajouter au magasin ; cet objet peut être utilisé dans un gexp. Si file est une chaîne littérale désignant un nom de fichier relatif, il est recherché par rapport au fichier source où il apparaît ; si file n’est pas une chaîne littérale, il est recherché par rapport au répertoire de travail courant au moment de l’exécution. file sera ajouté au dépôt sous name–par défaut le nom de base de file.

Lorsque recursive? est vraie, le contenu de file est ajouté récursivement ; si file désigne un fichier simple et que recursive? est vrai, son contenu est ajouté et ses bits de permissions sont préservés.

Lorsque recursive? est vraie, appelle (select? file stat) pour chaque répertoire où file est le nom de fichier absolu de l’entrée et stat est le résultat de lstat ; à l’exception des entrées pour lesquelles select? ne renvoie pas vrai.

C’est la version déclarative de la procédure monadique interned-file (voir interned-file).

Procédure Scheme : plain-file name content

Renvoie un objet représentant un fichier texte nommé name avec pour contenu content (une chaîne de caractères ou un vecteur d’octets) à ajouter un dépôt.

C’est la version déclarative de text-file.

Procédure Scheme : computed-file name gexp [#:local-build ? #t] [#:options '()]

Renvoie un objet représentant l’élément du dépôt name, un fichier ou un répertoire calculé par gexp. Lorsque local-build? est vrai (par défaut), la dérivation est construite localement. options est une liste d’arguments supplémentaires à passer à gexp->derivation.

C’est la version déclarative de gexp->derivation.

Procédure monadique : gexp->script name exp [#:guile (default-guile)] [#:module-path %load-path] [#:system (%current-system)] [#:target #f]

Renvoie un script exécutable name qui exécute exp en utilisant guile, avec les modules importés de exp dans son chemin de recherche. Recherchez les modules de exp dans module-path.

L’exemple ci-dessous construit un script qui invoque simplement la commande ls :

(use-modules (guix gexp) (gnu packages base))

(gexp->script "list-files"
              #~(execl #$(file-append coreutils "/bin/ls")
                       "ls"))

Lorsqu’elle est « lancée » à travers le dépôt (voir run-with-store), on obtient une dérivation qui produit une fichier exécutable /gnu/store/…-list-files qui ressemble à :

#!/gnu/store/…-guile-2.0.11/bin/guile -ds
!#
(execl "/gnu/store/…-coreutils-8.22"/bin/ls" "ls")
Procédure Scheme : program-file name exp [#:guile #f] [#:module-path %load-path]

Renvoie un objet représentant un élément du dépôt name qui lance gexp. guile est le paquet Guile à utiliser pour exécuter le script. Les modules importés par gexp sont recherchés dans module-path.

C’est la version déclarative de gexp->script.

Procédure monadique : gexp->file name exp [#:set-load-path? #t] [#:module-path %load-path] [#:splice? #f] [#:guile (default-guile)]

Renvoie une dérivation qui construit un fichier name contenant exp. Lorsque splice? est vrai, exp est considéré comme une liste d’expressions qui seront splicée dans le fichier qui en résulte.

Lorsque set-load-path? est vrai, émet du code dans le fichier de résultat pour initialiser %load-path et %load-compiled-path pour honorer les modules importés de exp. Les modules de exp sont trouvés dans module-path.

Le fichier qui en résulte retient les références à toutes les dépendances de exp ou un sous-ensemble.

Procédure Scheme : scheme-file name gexp [#:splice? #f] [#:set-load-path? #t] Renvoie un objet représentant le

fichier Scheme name qui contient exp.

C’est la version déclarative de gexp->file.

Procédure monadique : text-file* name text

Renvoie une valeur monadique qui construit un ficher texte contenant text. text peut lister, en plus de chaînes de caractères, des objet de n’importe quel type qui peut être utilisé dans une gexp : des paquets, des dérivations, des fichiers objet locaux, etc. Le fichier du dépôt qui en résulte en retient toutes les références.

Cette variante devrait être préférée à text-file lorsque vous souhaitez créer des fichiers qui référencent le dépôt. Cela est le cas typiquement lorsque vous construisez un fichier de configuration qui contient des noms de fichiers du dépôt, comme ceci :

(define (profile.sh)
  ;; Renvoie le nom d'un script shell dans le dépôt qui initialise
  ;; la variable d'environnement « PATH ».
  (text-file* "profile.sh"
              "export PATH=" coreutils "/bin:"
              grep "/bin:" sed "/bin\n"))

Dans cet exemple, le fichier /gnu/store/…-profile.sh qui en résulte référence coreutils, grep et sed, ce qui les empêche d’être glanés tant que le script est accessible.

Procédure Scheme : mixed-text-file name text

Renvoie un objet représentant le fichier du dépôt name contenant text. text est une séquence de chaînes de caractères et de fichiers simili-objets, comme dans :

(mixed-text-file "profile"
                 "export PATH=" coreutils "/bin:" grep "/bin")

C’est la version déclarative de text-file*.

Procédure Scheme : file-union name files

Renvoie un <computed-file> qui construit un répertoire qui contient tous les fichiers de files. Chaque élément de files doit être une paire où le premier élément est le nom de fichier à utiliser dans le nouveau répertoire et le second élément est une gexp dénotant le fichier cible. Voici un exemple :

(file-union "etc"
            `(("hosts" ,(plain-file "hosts"
                                    "127.0.0.1 localhost"))
              ("bashrc" ,(plain-file "bashrc"
                                     "alias ls='ls --color=auto'"))))

Cela crée un répertoire etc contenant ces deux fichiers.

Procédure Scheme : directory-union name things

Renvoie un répertoire qui est l’union de things, où things est une liste d’objets simili-fichiers qui dénotent des répertoires. Par exemple :

(directory-union "guile+emacs" (list guile emacs))

crée un répertoire qui est l’union des paquets guile et emacs.

Procédure Scheme : file-append obj suffix

Renvoie un objet simili-fichier qui correspond à la concaténation de obj et suffixobj est un objet abaissable et chaque suffix est une chaîne de caractères.

Par exemple, considérez cette gexp :

(gexp->script "run-uname"
              #~(system* #$(file-append coreutils
                                        "/bin/uname")))

On peut obtenir le même effet avec :

(gexp->script "run-uname"
              #~(system* (string-append #$coreutils
                                        "/bin/uname")))

Il y a une différence cependant : dans le cas file-append, le script qui en résulte contient le nom de fichier absolu comme une chaîne de caractère alors que dans le deuxième cas, le script contient une expression (string-append …) pour construire le nom de fichier à l’exécution.

Syntaxe Scheme : let-system system body
Syntaxe Scheme : let-system (system target) body

Lier system au système actuellement visé—par exemple, "x86_64-linux"—dans body.

Dans le second cas, lier également target à la cible de compilation croisée actuelle–un triplet GNU tel que "arm-linux-gnueabihf"—ou #f si nous ne faisons pas de compilation croisée.

let-system est utile occasionellement dans le cas où l’objet raccordé au gexp dépend de la cible sur le système cible, comme dans cet exemple :

#~(system*
   #+(let-system system
       (cond ((string-prefix? "armhf-" system)
              (file-append qemu "/bin/qemu-system-arm"))
             ((string-prefix? "x86_64-" system)
              (file-append qemu "/bin/qemu-system-x86_64"))
             (else
              (error "dunno!"))))
   "-net" "user" #$image)
   
Syntaxe Scheme : with-parameters ((parameter value) …) exp

Cette macro est similaire à la forme parameterize pour les paramètres liés dynamiquement (voir Parameters dans GNU Guile Reference Manual). La principale différence est qu’il prend effet lorsque l’objet de type fichier renvoyé par exp est abaissé à un élément de dérivation ou de stockage.

Une utilisation typique de with-parameters consiste à forcer le système en vigueur pour un objet donné :

(with-parameters ((%current-system "i686-linux"))
  coreutils)

L’exemple ci-dessus renvoie un objet qui correspond à la version i686 de Coreutils, quelle que soit la valeur actuelle de %current-système.

Bien sûr, en plus de gexps inclues dans le code « hôte », certains modules contiennent des outils de construction. Pour savoir facilement qu’ils sont à utiliser dans la strate de construction, ces modules sont gardés dans l’espace de nom (guix build …).

En interne, les objets de haut-niveau sont abaissés, avec leur compilateur, soit en des dérivations, soit en des objets du dépôt. Par exemple, abaisser un paquet crée une dérivation, et abaisser un plain-file crée un élément du dépôt. Cela est effectué par la procédure monadique lower-object.

Procédure monadique : lower-object obj [system] [#:target #f]

Renvoie comme valeur dans %store-monad la dérivation ou l’élément de dépôt correspondant à obj pour system, en effectuant une compilation croisée pour target si target est vrai. obj doit être un objet auquel est associé un compilateur gexp, tel qu’un <package>.


Précédent: , Monter: Interface de programmation   [Table des matières][Index]

8.11 Invoquer guix repl

La commande guix repl facilite la programmation de Guix dans Guile en lançant une boucle Guile read-eval-print. (REPL) pour la programmation interactive (voir Using Guile Interactively dans GNU Guile Reference Manual), ou en exécutant des scripts Guile (voir (GNU Guile Reference Manual)guile). Par rapport au simple lancement de la commande guile, guix repl garantit que tous les modules Guix et toutes ses dépendances sont disponibles dans le chemin de recherche.

La syntaxe générale est :

guix repl option fichier args]

Lorsqu’un argument file est fourni, file est exécuté comme un script Guile :

guix repl mon-script.scm

Pour passer des arguments au script, utilisez -- pour éviter qu’ils ne soient interprétés comme des arguments pour guix repl lui-même :

guix repl -- mon-script.scm --input=foo.txt

Pour rendre exécutable un script directement depuis le shell, en utilisant l’exécutable guix qui se trouve dans le chemin de recherche utilisateur·rice, ajoutez les deux lignes suivantes en haut du script :

#!/usr/bin/env -S guix repl --
!#

En l’absence d’un argument de nom de fichier, un REPL guile est lancé :

$ guix repl
scheme@(guile-user)> ,use (gnu packages base)
scheme@(guile-user)> coreutils
$1 = #<package coreutils@8.29 gnu/packages/base.scm:327 3e28300>

En plus, guix repl implémente un protocole REPL simple lisible par une machine à utiliser avec (guix inferior), un dispositif pour interagir avec des inférieurs, des processus séparés qui font tourner une version potentiellement différente de Guix.

Les options disponibles sont les suivante :

--type=type
-t type

Démarrer un REPL du type donné, qui peut être l’un de ces types :

guile

C’est la valeur par défaut. Elle démarre un REPL Guile standard fonctionnel.

machine

Démarre un REPL qui utilise le protocole lisible par machine. C’est le protocole que parle le module (guix inferior).

--listen=extrémité

Par défaut, guix repl lit depuis l’entrée standard et écrit sur la sortie standard. Lorsque cette option est passée, il écoutera plutôt les connexions sur endpoint. Voici un exemple d’options valides :

--listen=tcp:37146

Accepte les connexions sur localhost, sur le port 31.

--listen=unix:/tmp/socket

Accepte les connexions sur le socket Unix-domain /tmp/socket.

--load-path=répertoire
-L répertoire

Ajoute répertoire au début du chemin de recherche de module de paquets (voir Modules de paquets).

Cela permet à des utilisateurs de définir leur propres paquets et les rendre disponibles au script ou au REPL.

-q

Inhiber le chargement du fichier ~/.guile. Par défaut, ce fichier de configuration est chargé lors de la création d’un fichier guile. REPL.


Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

9 Utilitaires

Cette section décrit les utilitaires en ligne de commande de Guix. certains sont surtout faits pour les personnes qui écrivent de nouvelles définitions de paquets tandis que d’autres sont plus utiles pour une utilisation générale. Ils complètent l’interface de programmation Scheme de Guix d’une manière pratique.


Suivant: , Monter: Utilitaires   [Table des matières][Index]

9.1 Invoquer guix build

La commande guix build construit des paquets ou des dérivations et leurs dépendances et affiche les chemins du dépôt qui en résulte. Remarquez qu’elle ne modifie pas le profil de l’utilisateur — c’est le travail de la commande guix package (voir Invoquer guix package). Ainsi, elle est surtout utile pour les personnes qui développent la distribution.

La syntaxe générale est :

guix build options package-or-derivation

Par exemple, la commande suivante construit la dernière version d’Emacs et de Guile, affiche leur journaux de construction et enfin affiche les répertoires des résultats :

guix build emacs guile

De même, la commande suivante construit tous les paquets disponibles :

guix build --quiet --keep-going \
  `guix package -A | cut -f1,2 --output-delimiter=@`

package-or-derivation peut être soit le nom d’un paquet trouvé dans la distribution logicielle comme coreutils, soit coreutils@8.20, soit une dérivation comme /gnu/store/…-coreutils-8.19.drv. Dans le premier cas, la commande cherchera un paquet avec le nom correspondant (et éventuellement la version) dans les modules de la distribution GNU (voir Modules de paquets).

Autrement, l’option --expression peut être utilisée pour spécifier une expression Scheme qui s’évalue en un paquet ; c’est utile lorsqu’il est nécessaire de faire la distinction entre plusieurs paquets ou variantes de paquets portant le même nom.

Il peut y avoir aucune, une ou plusieurs options. Les options disponibles sont décrites dans les sous-sections ci-dessous.


Suivant: , Monter: Invoquer guix build   [Table des matières][Index]

9.1.1 Options de construction communes

Un certain nombre d’options qui contrôlent le processus de construction sont communes avec guix build et les autres commandes qui peuvent générer des constructions, comme guix package ou guix archive. Voici ces options :

--load-path=répertoire
-L répertoire

Ajoute répertoire au début du chemin de recherche de module de paquets (voir Modules de paquets).

Cela permet à des utilisateurs de définir leur propres paquets et les rendre disponibles aux outils en ligne de commande.

--keep-failed
-K

Garde l’arborescence de construction des constructions en échec. Ainsi, si une construction échoue, son arborescence de construction est préservée dans /tmp, dans un répertoire dont le nom est affiché à la fin du journal de construction. Cela est utile pour déboguer des échecs de construction. Voir Débogage des échecs de construction, pour des astuces sur la manière de déboguer des problèmes de construction.

Cette option implique --no-offload, et elle n’a pas d’effet quand elle est connectée à un démon distant avec une guix:// URI (voir the GUIX_DAEMON_SOCKET variable).

--keep-going
-k

Continue lorsque certaines dérivations échouent ; ne s’arrête que lorsque toutes les constructions ont soit réussies, soit échouées.

Le comportement par défaut est de s’arrêter dès qu’une des dérivations spécifiées échoue.

--dry-run
-n

Ne pas construire les dérivations.

--fallback

Lorsque la substitution d’un binaire pré-compilé échoue, construit les paquets localement à la place (voir Échec de substitution).

--substitute-urls=urls

Considère urls comme une liste d’URL de sources de substituts séparés par des espaces, et remplace la liste par défaut d’URL de guix-daemon (voir guix-daemon URLs).

Cela signifie que les substituts peuvent être téléchargés depuis urls, tant qu’ils sont signés par une clef autorisée par l’administrateur système (voir Substituts).

Lorsque urls est la chaîne vide, cela a pour effet de désactiver la substitution.

--no-substitutes

Ne pas utiliser de substitut pour les résultats de la construction. C’est-à-dire, toujours construire localement plutôt que de permettre le téléchargement de binaires pré-construits (voir Substituts).

--no-grafts

Ne par « greffer » les paquets. En pratique, cela signifie que les mises à jour des paquets disponibles comme des greffes ne sont pas appliquées. Voir Mises à jour de sécurité, pour plus d’information sur les greffes.

--rounds=n

Construit chaque dérivation n fois d’affilé, et renvoie une erreur si les constructions consécutives ne sont pas identiques bit-à-bit.

Cela est une manière utile pour détecter des processus de construction non déterministes. Les processus de construction non déterministes sont problématiques car ils rendent pratiquement impossible la vérification par les utilisateurs de l’authenticité de binaires tiers. Voir Invoquer guix challenge, pour plus d’informations.

Lorsqu’utilisé avec --keep-failed, la sortie différente est gardée dans le dépôt sous /gnu/store/…-check. Cela rend plus facile l’étude des différences entre les deux résultats.

--no-offload

N’essaye pas de décharger les constructions vers d’autres machines (voir Réglages du délestage du démon). C’est-à-dire que tout sera construit localement au lieu de décharger les constructions à une machine distante.

--max-silent-time=secondes

Lorsque le processus de construction ou de substitution restent silencieux pendant plus de secondes, le terminer et rapporter une erreur de construction.

Par défaut, le paramètre du démon est pris en compte (voir --max-silent-time).

--timeout=secondes

De même, lorsque le processus de construction ou de substitution dure plus de secondes, le terminer et rapporter une erreur de construction.

Par défaut, le paramètre du démon est pris en compte (voir --timeout).

-v [niveau]
--verbosity=niveau

Utiliser le niveau de verbosité, en tant qu’entier. 0 signifie qu’aucune sortie n’est produite, 1 signifie une sortie silencieuse et 2 montre tous les journaux de construction sur la sortie d’erreur standard.

--cores=n
-c n

Permet d’utiliser jusqu’à n cœurs du CPU pour la construction. La valeur spéciale 0 signifie autant de cœurs que possible.

--max-jobs=n
-M n

Permettre au maximum à n de construire des jobs en parallèle. Voir --max-jobs, pour plus de détails sur cette option et l’option équivalente guix-daemon.

--debug=niveau

Produire une sortie de débogage qui provient du démon de construction. niveau doit être un entier entre 0 et 5 ; plus grand est ce nombre, plus verbeuse sera la sortie. Indiquer un niveau de 4 ou plus peut être utile pour déboguer des problèmes d’installation avec le démon de construction.

Sous le capot, guix build est surtout une interface à la procédure package-derivation du module (guix packages), et à la procédure build-derivations du module (guix derivations).

En plus des options passées explicitement par la ligne de commande, guix build et les autres commandes guix qui peuvent effectuer des constructions permettent la variable d’environnement GUIX_BUILD_OPTIONS.

Variable d'environnement : GUIX_BUILD_OPTIONS

Les utilisateurs peuvent définir cette variable à une liste d’options de la ligne de commande qui seront automatiquement utilisées par guix build et les autres commandes guix qui peuvent effectuer des constructions, comme dans l’exemple suivant :

$ export GUIX_BUILD_OPTIONS="--no-substitutes -c 2 -L /foo/bar"

Ces options sont analysées indépendamment, et le résultat est ajouté aux options de la ligne de commande analysées.


Suivant: , Précédent: , Monter: Invoquer guix build   [Table des matières][Index]

9.1.2 Options de transformation de paquets

Un autre ensemble d’options de la ligne de commande supportés par guix build et aussi guix package sont les options de transformation de paquets. Ce sont des options qui rendent possible la définition de variantes de paquets — par exemple, des paquets construit à partir de sources différentes. C’est une manière simple de créer des paquets personnalisés à la volée sans avoir à taper les définitions de variantes de paquets (voir Définition des paquets).

Les options de transformation des paquets sont préservées dans les mises à jour : guix upgrade tente d’appliquer aux paquets mis à jour les options de transformation initialement utilisées lors de la création du profil.

Les options disponibles sont énumérées ci-dessous. La plupart des commandes les prennent en charge, ainsi qu’une option --help-transform qui liste toutes les options disponibles et un synopsis (ces options ne sont pas affichées dans la sortie --help par souci de concision).

--with-source=source
--with-source=paquet=source
--with-source=paquet@version=source

Utilise source comme la source de paquet, et version comme son numéro de version. source doit être un nom de fichier ou une URL, comme pour guix download (voir Invoquer guix download).

Lorsque paquet est omis, la commande utilisera le nom de paquet spécifié par la base de source — p. ex. si source est /src/guix-2.0.10.tar.gz, le paquet correspondant est guile.

De même, lorsque version est omis, la chaîne de version est inférée à partir de source ; dans l’exemple précédent, il s’agit de 2.0.10.

Cette option permet aux utilisateurs d’essayer des version des paquets différentes de celles fournies par la distribution. L’exemple ci-dessous télécharge ed-1.7.tar.g depuis un miroir GNU et l’utilise comme source pour le paquet ed :

guix build ed --with-source=mirror://gnu/ed/ed-1.7.tar.gz

En tant que développeur·euse, --with-source permet de tester facilement des version bêta :

guix build guile --with-source=../guile-2.0.9.219-e1bb7.tar.xz

… ou pour construire un dépôt de gestion de version dans un environnement vierge :

$ git clone git://git.sv.gnu.org/guix.git
$ guix build guix --with-source=guix@1.0=./guix
--with-input=paquet=remplaçant

Remplace la dépendance sur paquet par une dépendance à remplaçant. paquet doit être un nom de paquet et remplaçant doit être une spécification de paquet comme guile ou guile@1.8.

Par exemple, la commande suivante construit Guix, mais remplace sa dépendance à la version stable actuelle de Guile par une dépendance à une ancienne version de Guile, guile@2.0 :

guix build --with-input=guile=guile@2.0 guix

C’est un remplacement récursif profond. Donc dans cet exemple, à la fois guix et ses dépendances guile-json (qui dépend aussi de guile) sont reconstruits avec guile@2.0.

Cette option est implémentée avec la procédure Scheme package-input-rewriting (voir package-input-rewriting).

--with-graft=paquet=remplaçant

Cette option est similaire à --with-input mais avec une différence importante : plutôt que de reconstruire la chaîne de dépendance complète, remplaçant est construit puis greffé sur les binaires qui référençaient initialement paquet. Voir Mises à jour de sécurité, pour plus d’information sur les greffes.

Par exemple, la commande ci-dessous greffe la version 3.5.4 de GnuTLS sur Wget et toutes ses dépendances, en remplaçant les références à la version actuelle de GnuTLS à laquelle ils se réfèrent actuellement :

guix build --with-graft=gnutls=gnutls@3.5.4 wget

Cela a l’avantage d’être bien plus rapide que de tout reconstruire. Mais il y a un piège : cela ne fonctionne que si paquet et remplaçant sont strictement compatibles — par exemple, s’ils fournissent une bibliothèque, l’interface binaire applicative (ABI) de ces bibliothèques doivent être compatibles. Si remplaçant est incompatible avec paquet, alors le paquet qui en résulte peut devenir inutilisable. À utiliser avec précaution !

--with-debug-info=paquet

Construire paquet de manière à préserver ses informations de débogage et les greffer sur les paquets qui en dépendent. Cela est utile si paquet ne fournit pas déjà les informations de débogage sous forme de sortie debug (voir Installer les fichiers de débogage).

Par exemple, supposons que vous subissiez un plantage de Inkscape et que vous vouliez voir ce qui se passe dans GLib, une bibliothèque au fond du graphe de dépendance d’Inkscape. GLib n’a pas de sortie debug, donc le débogage est difficile. Heureusement, vous reconstruisez la GLib avec les informations de débogage et vous l’installez dans Inkscape :

guix install inkscape --with-debug-info=glib

Seule GLib doit être recompilée, ce qui prend un temps raisonnable. Voir Installer les fichiers de débogage, pour plus d’informations.

Remarque : Sous le capot, cette option fonctionne en passant par le ‘#:strip-binaries ? #f’ au système de construction du paquet qui nous intéresse (voir Systèmes de construction). La plupart des systèmes de compilation supportent cette option, mais certains ne le font pas. Dans ce cas, une erreur se produit.

De même, si un paquet C/C++ est construit sans -g (ce qui est rarement le cas), les informations de débogage resteront indisponibles même si #:strip-binaries? est faux.

--with-c-toolchain=package=toolchain

Cette option modifie la compilation de package et de tout ce qui en dépend afin qu’ils soient construits avec toolchain au lieu de la chaîne d’outils GNU par défaut pour C/C++.

Regardez cet exemple :

guix build octave-cli \
  --with-c-toolchain=fftw=gcc-toolchain@10 \
  --with-c-toolchain=fftwf=gcc-toolchain@10

La commande ci-dessus construit une variante des paquets fftw et fftwf en utilisant la version 10 de gcc-toolchain au lieu de la chaîne d’outils par défaut, puis construit une variante de l’interface en ligne de commande GNU Octave en les utilisant. GNU Octave lui-même est également construit avec gcc-toolchain@10.

Cet autre exemple construit la bibliothèque Hardware Locality (hwloc) et ses dépendances jusqu’à intel-mpi-benchmarks avec le compilateur Clang C :

guix build --with-c-toolchain=hwloc=clang-toolchain \
           intel-mpi-benchmarks

Remarque : There can be application binary interface (ABI) incompatibilities among tool chains. This is particularly true of the C++ standard library and run-time support libraries such as that of OpenMP. By rebuilding all dependents with the same tool chain, --with-c-toolchain minimizes the risks of incompatibility but cannot entirely eliminate them. Choose package wisely.

--with-git-url=paquet=url

Construire paquet depuis le dernier commit de la branche master du dépôt sur url. Les sous-modules Git du dépôt sont récupérés, récursivement.

Par exemple, la commande suivante construit la bibliothèque Python NumPy avec le dernier commit de la branche master de Python lui-même :

guix build python-numpy \
  --with-git-url=python=https://github.com/python/cpython

Cette option peut aussi être combinée avec --with-branch ou --with-commit (voir plus bas).

Évidemment, comme cela utilise le dernier commit d’une branche donnée, le résultat d’une telle commande varie avec le temps. Néanmoins c’est une manière pratique pour reconstruire des piles logicielles entières avec le dernier commit d’un ou plusieurs paquets. C’est particulièrement pratique dans le contexte d’une intégration continue.

Les clones sont gardés dans un cache dans ~/.cache/guix/checkouts pour accélérer les accès consécutifs au même dépôt. Vous pourriez vouloir le nettoyer de temps en temps pour récupérer de l’espace disque.

--with-branch=paquet=branche

Construire paquet à partir du dernier commit de la branche. Si le champ source de paquet est une origine avec la méthode git-fetch (voir référence des origines) ou un objet git-checkout, l’URL du dépôt est récupérée à partir de cette source. Sinon, vous devez utiliser --with-git-url pour spécifier l’URL du dépôt Git.

Par exemple, la commande suivante construit guile-sqlite3 à partir du dernier commit de sa branche master, puis construit guix (qui en dépend) et cuirass (qui dépend de guix) avec cette construction spécifique de guile-sqlite3 :

guix build --with-branch=guile-sqlite3=master cuirass
--with-commit=paquet=commit

Cela est similaire à --with-branch, sauf qu’elle construite à partir de commit au lieu du sommet d’une branche. commit doit être un identifiant SHA1 de commit Git valide ou un tag.

--with-patch=package=file

Add file to the list of patches applied to package, where package is a spec such as python@3.8 or glibc. file must contain a patch; it is applied with the flags specified in the origin of package (voir référence des origines), which by default includes -p1 (voir patch Directories dans Comparing and Merging Files).

As an example, the command below rebuilds Coreutils with the GNU C Library (glibc) patched with the given patch:

guix build coreutils --with-patch=glibc=./glibc-frob.patch

In this example, glibc itself as well as everything that leads to Coreutils in the dependency graph is rebuilt.

--with-latest=package

So you like living on the bleeding edge? This option is for you! It replaces occurrences of package in the dependency graph with its latest upstream version, as reported by guix refresh (voir Invoquer guix refresh).

It does so by determining the latest upstream release of package (if possible), downloading it, and authenticating it if it comes with an OpenPGP signature.

As an example, the command below builds Guix against the latest version of Guile-JSON:

guix build guix --with-latest=guile-json

There are limitations. First, in cases where the tool cannot or does not know how to authenticate source code, you are at risk of running malicious code; a warning is emitted in this case. Second, this option simply changes the source used in the existing package definitions, which is not always sufficient: there might be additional dependencies that need to be added, patches to apply, and more generally the quality assurance work that Guix developers normally do will be missing.

You’ve been warned! In all the other cases, it’s a snappy way to stay on top. We encourage you to submit patches updating the actual package definitions once you have successfully tested an upgrade (voir Contribuer).

--without-tests=paquet

Construire paquet sans lancer la suite de tests. Celà peut être utile dans les situations où vous voulez éviter la longue série de tests d’un paquet intermédiaire, ou si une suite de tests de paquet échoue dans un mode non déterministe. Il doit être utilisé avec précaution car l’exécution de la suite de tests est un bon moyen de s’assurer qu’un paquet fonctionne comme prévu.

L’arrêt des tests conduit à un autre élément du dépôt. Par conséquent, lorsque vous utilisez cette option, tout ce qui dépend de paquet doit être reconstruit, comme dans cet exemple :

guix install --without-tests=python python-notebook

La commande ci-dessus installe python-notebook par dessus python, construit sans exécuter sa suite de tests. Pour ce faire, elle reconstruit également tout ce qui dépend de python, y compris python-notebook lui-même.

En interne, --without-tests repose sur le changement de l’option #:tests? de la phase check d’un paquet (voir Systèmes de construction). Notez que certains paquets utilisent une phase check personnalisée qui ne respecte pas le paramètre #:tests? #f. Par conséquent, --without-tests n’a aucun effet sur ces paquets.

Vous vous demandez comme faire la même chose dans du code Scheme, par exemple dans votre manifeste, ou comme écrire votre propre transformation de paquets ? Voir Définition de variantes de paquets, pour un aperçu des interfaces de programmation disponibles.


Suivant: , Précédent: , Monter: Invoquer guix build   [Table des matières][Index]

9.1.3 Options de construction supplémentaires

Les options de la ligne de commande ci-dessous sont spécifiques à guix build.

--quiet
-q

Construire silencieusement, sans afficher les journaux de construction ; c’est équivalent à --verbosity=0. À la fin, le journal de construction est gardé dans /var (ou similaire) et on peut toujours l’y trouver avec l’option --log-file.

--file=fichier
-f fichier

Construit le paquet, la dérivation ou l’objet simili-fichier en lequel le code dans file s’évalue (voir file-like objects).

Par exemple, file peut contenir une définition de paquet comme ceci (voir Définition des paquets) :

(use-modules (guix)
             (guix build-system gnu)
             (guix licenses))

(package
  (name "hello")
  (version "2.10")
  (source (origin
            (method url-fetch)
            (uri (string-append "mirror://gnu/hello/hello-" version
                                ".tar.gz"))
            (sha256
             (base32
              "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
  (build-system gnu-build-system)
  (synopsis "Hello, GNU world: An example GNU package")
  (description "Guess what GNU Hello prints!")
  (home-page "http://www.gnu.org/software/hello/")
  (license gpl3+))

file peut également contenir une représentation JSON d’une ou plusieurs définitions de paquets. L’exécution de guix build -f sur hello.json avec le contenu suivant entraînerait la construction des paquets myhello et greeter :

[
  {
    "name": "myhello",
    "version": "2.10",
    "source": "mirror://gnu/hello/hello-2.10.tar.gz",
    "build-system": "gnu",
    "arguments": {
      "tests?": false
    }
    "home-page": "https://www.gnu.org/software/hello/",
    "synopsis": "Hello, GNU world: An example GNU package",
    "description": "GNU Hello prints a greeting.",
    "license": "GPL-3.0+",
    "native-inputs": ["gettext"]
  },
  {
    "name": "greeter",
    "version": "1.0",
    "source": "https://example.com/greeter-1.0.tar.gz",
    "build-system": "gnu",
    "arguments": {
      "test-target": "foo",
      "parallel-build?": false,
    },
    "home-page": "https://example.com/",
    "synopsis": "Greeter using GNU Hello",
    "description": "This is a wrapper around GNU Hello.",
    "license": "GPL-3.0+",
    "inputs": ["myhello", "hello"]
  }
]
--manifest=manifest
-m manifest

Construire tous les paquets listés dans un manifest donné (voir --manifest).

--expression=expr
-e expr

Construit le paquet ou la dérivation en lequel expr s’évalue.

Par exemple, expr peut être (@ (gnu packages guile) guile-1.8), qui désigne sans ambiguïté cette variante spécifique de la version 1.8 de Guile.

Autrement, exp peut être une G-expression, auquel cas elle est utilisée comme un programme de construction passé à gexp->derivation (voir G-Expressions).

Enfin, expr peut se référer à une procédure monadique à au moins un argument (voir La monade du dépôt). La procédure doit renvoyer une dérivation comme une valeur monadique, qui est ensuite lancée à travers run-with-store.

--source
-S

Construit les dérivation source des paquets, plutôt que des paquets eux-mêmes.

Par exemple, guix build -S gcc renvoie quelque chose comme /gnu/store/…-gcc-4.7.2.tar.bz2, qui est l’archive des sources de GCC.

L’archive des sources renvoyée est le résultat de l’application des correctifs et des extraits de code éventuels spécifiés dans le champ origin du paquet (voir Définition des paquets).

As with other derivations, the result of building a source derivation can be verified using the --check option (voir vérification de la construction). This is useful to validate that a (potentially already built or substituted, thus cached) package source matches against its declared hash.

Notez que guix build -S compile seulement les sources des paquets spécifiés. Les sources de dépendances statiquement liées ne sont pas incluses et sont en elles-mêmes insuffisantes pour reproduire les paquets.

--sources

Récupère et renvoie la source de package-or-derivation et toute ses dépendances, récursivement. C’est pratique pour obtenir une copie locale de tous les codes sources requis pour construire packages, ce qui vous permet de les construire plus tard même sans accès au réseau. C’est une extension de l’option --source et elle peut accepter l’un des arguments facultatifs suivants :

package

Cette valeur fait que l’option --sources se comporte comme l’option --source.

all

Construit les dérivations des sources de tous les paquets, dont les sources qui pourraient être listées dans inputs. C’est la valeur par défaut.

$ guix build --sources tzdata
The following derivations will be built:
   /gnu/store/…-tzdata2015b.tar.gz.drv
   /gnu/store/…-tzcode2015b.tar.gz.drv
transitive

Construire les dérivations des sources de tous les paquets, ainsi que toutes celles des entrées transitives des paquets. On peut par exemple utiliser cette option pour précharger les sources des paquets pour les construire plus tard hors ligne.

$ guix build --sources=transitive tzdata
The following derivations will be built:
   /gnu/store/…-tzcode2015b.tar.gz.drv
   /gnu/store/…-findutils-4.4.2.tar.xz.drv
   /gnu/store/…-grep-2.21.tar.xz.drv
   /gnu/store/…-coreutils-8.23.tar.xz.drv
   /gnu/store/…-make-4.1.tar.xz.drv
   /gnu/store/…-bash-4.3.tar.xz.drv
…
--system=système
-s système

Essayer de construire pour system — p. ex. i686-linux — au lieu du type de système de l’hôte. La commande guix build vous permet de répéter cette option plusieurs fois, auquel cas elle construit pour tous les systèmes spécifiés ; les autres commandes ignorent les options -s supplémentaires.

Remarque : Le drapeau --system est utilisé pour une compilation native et ne doit pas être confondu avec une compilation croisée. Voir --target ci-dessous pour des informations sur la compilation croisée.

Un exemple d’utilisation de ceci sur les systèmes Linux, qui peut émuler différentes personnalités. Par exemple, passer --system=i686-linux sur un système x86_64-linux ou --system=armhf-linux sur un système aarch64-linux vous permet de construire des paquets dans un environnement 32-bit complet.

Remarque : La possibilité de construire pour un système armhf-linux est activé sans condition sur les machines aarch64-linux, bien que certaines puces aarch64 n’en soient pas capables, comme les ThunderX.

De même, lorsque l’émulation transparente avec QEMU et binfnmt_misc est activée (voir qemu-binfmt-service-type), vous pouvez construire pour n’importe quel système pour lequel un gestionnaire QEMU binfmt_misc est installé.

Les constructions pour un autre système que celui de la machine que vous utilisez peuvent aussi être déchargées à une machine distante de la bonne architecture. Voir Réglages du délestage du démon, pour plus d’information sur le déchargement.

--target=triplet

Effectuer une compilation croisée pour triplet qui doit être un triplet GNU valide, comme "aarch64-linux-gnu" (voir GNU configuration triplets dans Autoconf).

--check

Reconstruit les package-or-derivation, qui sont déjà disponibles dans le dépôt et lève une erreur si les résultats des constructions ne sont pas identiques bit-à-bit.

Ce mécanisme vous permet de vérifier si les substituts précédemment installés sont authentiques (voir Substituts) ou si le résultat de la construction d’un paquet est déterministe. Voir Invoquer guix challenge pour plus d’informations et pour les outils.

Lorsqu’utilisé avec --keep-failed, la sortie différente est gardée dans le dépôt sous /gnu/store/…-check. Cela rend plus facile l’étude des différences entre les deux résultats.

--repair

Essaye de réparer les éléments du dépôt spécifiés, s’ils sont corrompus, en les téléchargeant ou en les construisant à nouveau.

Cette opération n’est pas atomique et donc restreinte à l’utilisateur root

--derivations
-d

Renvoie les chemins de dérivation, et non les chemins de sortie, des paquets donnés.

--root=fichier
-r fichier

Fait de fichier un lien symbolique vers le résultat, et l’enregistre en tant que racine du ramasse-miettes.

En conséquence, les résultats de cette invocation de guix build sont protégés du ramasse-miettes jusqu’à ce que fichier soit supprimé. Lorsque cette option est omise, les constructions sont susceptibles d’être glanées.

--log-file

Renvoie les noms des journaux de construction ou les URL des package-or-derivation donnés ou lève une erreur si les journaux de construction sont absents.

Cela fonctionne indépendamment de la manière dont les paquets ou les dérivations sont spécifiées. Par exemple, les invocations suivantes sont équivalentes :

guix build --log-file `guix build -d guile`
guix build --log-file `guix build guile`
guix build --log-file guile
guix build --log-file -e '(@ (gnu packages guile) guile-2.0)'

Si un journal n’est pas disponible localement, à moins que --no-substitutes ne soit passé, la commande cherche un journal correspondant sur l’un des serveurs de substituts (tels que spécifiés avec --substitute-urls.)

Donc par exemple, imaginons que vous souhaitiez voir le journal de construction de GDB sur MIPS, mais que vous n’avez qu’une machine x86_64 :

$ guix build --log-file gdb -s aarch64-linux
https://ci.guix.gnu.org/log/…-gdb-7.10

Vous pouvez accéder librement à un vaste bibliothèque de journaux de construction !


Précédent: , Monter: Invoquer guix build   [Table des matières][Index]

9.1.4 Débogage des échecs de construction

Lors de la définition d’un nouveau paquet (voir Définition des paquets), vous passerez probablement du temps à déboguer et modifier la construction jusqu’à ce que ça marche. Pour cela, vous devez effectuer les commandes de construction vous-même dans un environnement le plus proche possible de celui qu’utilise le démon de construction.

Pour cela, la première chose à faire est d’utiliser l’option --keep-failed ou -K de guix build, qui gardera la construction échouée de l’arborescence dans /tmp ou le répertoire spécifié par TMPDIR (voir --keep-failed).

À partir de là, vous pouvez vous déplacer dans l’arborescence de construction et sourcer le fichier environment-variables, qui contient toutes les variables d’environnement qui étaient définies lorsque la construction a échoué. Disons que vous déboguez un échec de construction dans le paquet foo ; une session typique ressemblerait à cela :

$ guix build foo -K
… build fails
$ cd /tmp/guix-build-foo.drv-0
$ source ./environment-variables
$ cd foo-1.2

Maintenant, vous pouvez invoquer les commandes comme si vous étiez le démon (presque) et corriger le processus de construction.

Parfois il arrive que, par exemple, les tests d’un paquet réussissent lorsque vous les lancez manuellement mais échouent quand ils sont lancés par le démon. Cela peut arriver parce que le démon tourne dans un conteneur où, contrairement à notre environnement au-dessus, l’accès réseau est indisponible, /bin/sh n’existe pas, etc. (voir Réglages de l'environnement de construction).

Dans ce cas, vous pourriez avoir besoin de lancer le processus de construction dans un conteneur similaire à celui que le démon crée :

$ guix build -K foo
…
$ cd /tmp/guix-build-foo.drv-0
$ guix environment --no-grafts -C foo --ad-hoc strace gdb
[env]# source ./environment-variables
[env]# cd foo-1.2

Ici, guix environment -C crée un conteneur et démarre un nouveau shell à l’intérieur (voir Invoquer guix environment). La partie --ad-hoc strace gdb ajoute les commandes strace et gdb dans le conteneur, ce qui pourrait s’avérer utile pour le débogage. L’option --no-grafts s’assure qu’on obtienne le même environnement, avec des paquets non greffés (voir Mises à jour de sécurité, pour plus d’informations sur les greffes).

Pour obtenir un conteneur plus proche de ce qui serait utilisé par le démon de construction, on peut enlever /bin/sh :

[env]# rm /bin/sh

(Ne vous inquiétez pas, c’est sans danger : tout cela se passe dans un conteneur jetable créé par guix environment.)

La commande strace n’est probablement pas dans le chemin de recherche, mais on peut lancer :

[env]# $GUIX_ENVIRONMENT/bin/strace -f -o log make check

De cette manière, non seulement vous aurez reproduit les variables d’environnement utilisées par le démon, mais vous lancerez aussi le processus de construction dans un conteneur similaire à celui utilisé par le démon.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.2 Invoquer guix edit

Tant de paquets, tant de fichiers source ! La commande guix edit facilite la vie des utilisateurs et des empaqueteurs en plaçant leur éditeur sur le fichier source qui contient la définition des paquets spécifiés. Par exemple :

guix edit gcc@4.9 vim

lance le programme spécifié dans la variable d’environnement VISUAL ou dans la variable d’environnement EDITOR pour visionner la recette de GCC 4.9.3 et celle de Vim.

Si vous utilisez une copie du dépôt Git de Guix (voir Construire depuis Git), ou que vous avez créé vos propres paquets dans GUIX_PACKAGE_PATH (voir Modules de paquets), vous pourrez modifier les recettes des paquets. Sinon, vous pourrez examiner les recettes en lecture-seule des paquets actuellement dans le dépôt.

Au lieu de GUIX_PACKAGE_PATH, l’option de la ligne de commande --load-path=directory (ou en bref -L directory) vous permet d’ajouter directory au début du chemin de recherche du module de paquet et donc de rendre vos propres paquets visibles.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.3 Invoquer guix download

Lorsqu’on écrit une définition de paquet, on a généralement besoin de télécharger une archive des sources, calculer son hash SHA256 et écrire ce hash dans la définition du paquet (voir Définition des paquets). L’outil guix download aide à cette tâche : il télécharge un fichier à l’URL donné, l’ajoute au dépôt et affiche à la fois son nom dans le dépôt et son hash SHA56.

Le fait que le fichier téléchargé soit ajouté au dépôt économise la bande passante : quand on construit ensuite le paquet nouvellement défini avec guix build, l’archive des sources n’a pas besoin d’être à nouveau téléchargée puisqu’elle se trouve déjà dans le dépôt. C’est aussi une manière pratique de garder des fichiers temporairement, qui pourront ensuite être supprimés (voir Invoquer guix gc).

La commande guix download supporte les mêmes URI que celles utilisées dans les définitions de paquets. En particulier, elle supporte les URI mirror://. Les URI http (HTTP sur TLS) sont supportées si les liaisons Guile de GnuTLS sont disponibles dans l’environnement de l’utilisateur ; si elle ne sont pas disponibles, une erreur est renvoyée. Voir how to install the GnuTLS bindings for Guile dans GnuTLS-Guile, pour plus d’informations.

guix download vérifie les certificats du serveur HTTPS en chargeant les autorités de certification X.509 depuis le répertoire vers lequel pointe la variable d’environnement SSL_CERT_DIR (voir Certificats X.509), à moins que --no-check-certificate ne soit utilisé.

Les options suivantes sont disponibles :

--hash=algorithme
-H algorithme

Calcule un hash en utilisant l’algorithme spécifié. Voir Invoquer guix hash, pour plus d’ informations.

--format=fmt
-f fmt

Écrit le hash dans le format spécifié par fmt. Pour plus d’informations sur les valeurs valides pour fmt, voir Invoquer guix hash.

--no-check-certificate

Ne pas valider les certificats HTTPS des serveurs.

Lorsque vous utilisez cette option, vous n’avez absolument aucune garanti que vous communiquez avec le serveur authentique responsable de l’URL donnée, ce qui vous rend vulnérable à des attaques de « l’homme du milieu ».

--output=fichier
-o fichier

Enregistre le fichier téléchargé dans fichier plutôt que de l’ajouter au dépôt.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.4 Invoquer guix hash

La commande guix hash calcule le hash d’un fichier. C’est surtout un outil pour simplifier la vie des contributeur·rice·s à la distribution : elle calcule le hash cryptographique d’un fichier, qui peut être utilisé dans la définition d’ un paquet (voir Définition des paquets).

La syntaxe générale est :

guix hash option fichier

Lorsque fichier est - (un tiret), guix hash calcul le hash des données lues depuis l’entrée standard. guix hash a les options suivantes :

--hash=algorithme
-H algorithme

Calcule un hash en utilisant l’ algorithme spécifié, sha256 par défaut.

algorithm doit être le nom de l’ algorithme d’un hash cryptographique supporté par Libgcrypt via Guile-Gcrypt—par exemple, sha512 ou sha3-256 (voir Hash Functions dans Guile-Gcrypt Reference Manual).

--format=fmt
-f fmt

Écrit le hash dans le format spécifié par fmt.

Formats supportés : base64, nix-base32, base32, base16 (hex et hexadecimal peuvent être utilisés).

Si l’option --format n’est pas spécifiée, guix hash affichera le hash en nix-base32. Cette représentation est utilisée dans les définitions des paquets.

--recursive
-r

Calcule le hash sur fichier récursivement.

Dans ce cas, le hash est calculé sur une archive contenant fichier, dont ses enfants si c’est un répertoire. Certaines métadonnées de fichier fait partie de l’archive ; par exemple lorsque fichier est un fichier normal, le hash est différent que le fichier soit exécutable ou non. Les métadonnées comme un horodatage n’ont aucun impact sur le hash (voir Invoquer guix archive).

--exclude-vcs
-x

Conjointement avec --recursive, exclut les répertoires de système de contrôle de version (.bzr, .git, .hg, etc.)

Par exemple, voici comment calculer le hash d’un dépôt Git, ce qui est utile avec la méthode git-fetch (voir référence des origines) :

$ git clone http://example.org/foo.git
$ cd foo
$ guix hash -rx .

Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.5 Invoquer guix import

La commande guix import est utile pour les gens qui voudraient ajouter un paquet à la distribution avec aussi peu de travail que possible — une demande légitime. La commande connaît quelques dépôts logiciels d’où elle peut « importer » des métadonnées de paquets. Le résultat est une définition de paquet, ou un modèle de définition, dans le format reconnu par Guix (voir Définition des paquets).

La syntaxe générale est :

guix import importer options

importer spécifie la source depuis laquelle importer des métadonnées de paquets, et options spécifie un identifiant de paquet et d’autres options spécifiques à importer.

Certains des importeurs s’appuient sur la capacité d’exécuter la commande gpgv. Pour ceux-ci, GnuPG doit être installé dans $PATH ; exécuter guix install gnupg si nécessaire.

Actuellement, les « importeurs » disponibles sont :

gnu

Importe des métadonnées d’un paquet GNU donné. Cela fournit un modèle pour la dernière version de ce paquet GNU, avec le hash de son archive, le synopsis et la description canonique.

Les informations supplémentaires comme les dépendances du paquet et sa licence doivent être renseignées manuellement.

Par exemple, la commande suivante renvoie une définition de paquets pour GNU Hello :

guix import gnu hello

Les options spécifiques sont :

--key-download=politique

Comme pour guix refresh, spécifie la politique de gestion des clefs OpenPGP manquantes lors de la vérification de la signature d’un paquet. Voir --key-download.

pypi

Importe des métadonnées depuis l’index des paquets Python. Les informations sont récupérées à partir de la description en JSON disponible sur pypi.python.org et inclus généralement toutes les informations utiles, dont les dépendances des paquets. Pour une efficacité maximale, il est recommandé d’installer l’utilitaire unzip, pour que l’importateur puisse dézipper les wheels Python et récupérer les informations contenues à l’intérieur.

La commande ci-dessous importe les métadonnées du paquet Python itsdangerous :

guix import pypi itsdangerous
--recursive
-r

Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix.

gem

Importe des métadonnées de RubyGems. Les informations sont récupérées au format JSON disponible sur rubygems.org et inclut les informations les plus utiles, comme les dépendances à l’exécution. Il y a des cependant quelques restrictions. Les métadonnées ne distinguent pas synopsis et description, donc la même chaîne est utilisée pour les deux champs. En plus, les détails des dépendances non Ruby requises pour construire des extensions natives sont indisponibles et laissé en exercice à l’empaqueteur.

La commande ci-dessous importe les métadonnées pour le paquet Ruby rails :

guix import gem rails
--recursive
-r

Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix.

cpan

Importe des métadonnées de MetaCPAN. Les informations sont récupérées au format JSON disponible à travers l’API de MetaCPAN et inclus les informations les plus utiles, comme les dépendances des modules. L’information sur les licences doit être vérifiée avec attention. Si Perl est disponible dans le dépôt, alors l’utilitaire corelist sera utiliser pour exclure les modules du cœur de la distribution Perl de la liste des dépendances.

La commande ci-dessous importe des métadonnées pour le module Acme::Boolean Perl :

guix import cpan Acme::Boolean
cran

Importe des métadonnées de CRAN, le dépôt central de l’environnement statistique et graphique GNU R.

L’ information est extraite du fichier DESCRIPTION du paquet.

La commande ci-dessous importe les métadonnées du paquet Cairo R :

guix import cran Cairo

Lorsque l’option --recursive est utilisée, l’importeur traversera le graphe des dépendances du paquet en amont récursivement et générera des expressions de paquets pour tous ceux qui ne sont pas déjà dans Guix.

When --style=specification is added, the importer will generate package definitions whose inputs are package specifications instead of references to package variables. This is useful when generated package definitions are to be appended to existing user modules, as the list of used package modules need not be changed. The default is --style=variable.

Lorsque --archive=bioconductor est ajoutée, les métadonnées sont importées depuis Bioconductor, un répertoire de paquets R pour l’analyse et la compréhension de données génomiques volumineuses en bioinformatique.

Les informations sont extraites du fichier DESCRIPTION du paquet contenu dans l’archive du paquet.

La commande ci-dessous importe les métadonnées pour le paquet R GenomicRanges :

guix import cran --archive=bioconductor GenomicRanges

Enfin, vous pouvez aussi importer des paquets R qui n’ont pas encore été publiés sur CRAN ou Bioconductor tant qu’ils ne sont pas dans le dépôt Git. Utilisez --archive=git suivi par l’URL du dépôt Git :

guix import cran --archive=git https://github.com/immunogenomics/harmony
texlive

Importe les métadonnées de CTAN, le réseau d’archive TeX complet pour les paquets TeX qui font partie de la distribution TeX Live.

Les informations sur les paquets sont obtenues à travers l’API XML fournie par CTAN, tandis que le code source est téléchargé depuis le dépôt SVN du projet Tex Live. Cette méthode est utilisée parce que CTAN ne garde pas d’archives versionnées.

La commande ci-dessous importe les métadonnées du paquet TeX fontspec :

guix import texlive fontspec

Lorsque l’option --archive=directory est ajoutée, le code source n’est pas téléchargé depuis le sous-répertoire latex du l’arborescence texmf-dist/source dans le dépôt SVN de TeX Live, mais depuis le répertoire voisin directory spécifié sous la même racine.

La commande ci-dessous importe les métadonnées du paquet ifxetex depuis CTAN en récupérant les sources depuis le répertoire texmf/source/generic :

guix import texlive --archive=generic ifxetex
json

Importe des métadonnées d’un fichier JSON local. Considérez l’exemple suivant d’une définition de paquet au format JSON :

{
  "name": "hello",
  "version": "2.10",
  "source": "mirror://gnu/hello/hello-2.10.tar.gz",
  "build-system": "gnu",
  "home-page": "https://www.gnu.org/software/hello/",
  "synopsis": "Hello, GNU world: An example GNU package",
  "description": "GNU Hello prints a greeting.",
  "license": "GPL-3.0+",
  "native-inputs": ["gettext"]
}

Les noms des champs sont les mêmes que pour les enregistrements de <package> (Voir Définition des paquets). Les référence à d’autres paquets sont fournies comme des listes JSON de chaînes de spécifications de paquets comme guile ou guile@2.0.

L’importateur supporte aussi une définition plus explicite des sources avec les champs habituels pour les enregistrements <origin> :

{
  …
  "source": {
    "method": "url-fetch",
    "uri": "mirror://gnu/hello/hello-2.10.tar.gz",
    "sha256": {
      "base32": "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"
    }
  }
  …
}

La commande ci-dessous lit les métadonnées du fichier JSON hello.json et renvoie une expression de paquet :

guix import json hello.json
nix

Importe les métadonnées d’une copie locale des source de la distribution Nixpkgs21. Les définitions de paquets dans Nixpkgs sont habituellement écrites en un mélange entre le langage Nix et Bash. Cette commande n’importe que la structure de haut-niveau du paquet qui est écrite dans le langage Nix. Elle inclut normalement tous les champs de base de la définition d’un paquet.

Lorsque vous importez un paquet GNU, le synopsis et la description sont replacés par la version canonique en amont.

Normalement, vous devrez d’abord faire :

export NIX_REMOTE=daemon

pour que nix-instantiate n’essaye pas d’ouvrir la base de données de Nix.

Par exemple, la commande ci-dessous importe la définition du paquet de LibreOffice (plus précisément, elle importe la définition du paquet lié à l’attribut de plus haut-niveau libreoffice) :

guix import nix ~/path/to/nixpkgs libreoffice
hackage

Importe les métadonnées de l’archive de paquets centrale de la communauté Haskell, Hackage. Les informations sont récupérées depuis les fichiers Cabal et incluent toutes les informations utiles, dont les dépendances des paquets.

Les options spécifiques sont :

--stdin
-s

Lit un fichier Cabal depuis l’entrée standard.

--no-test-dependencies
-t

N’inclut pas les dépendances requises uniquement par les suites de tests.

--cabal-environment=alist
-e alist

alist est une alist Scheme qui définie l’environnement dans lequel les conditions de Cabal sont évaluées. Les clefs acceptées sont : os, arch, impl et une représentation sous forme de chaîne de caractères du nom d’un drapeau. La valeur associée à un drapeau doit être le symbole true ou false. La valeur associée aux autres clefs doivent se conformer avec la définition du format de fichiers Cabal. La valeur par défaut associée avec les clefs os, arch et impl sont respectivement ‘linux’, ‘x86_64’ et ‘ghc’.

--recursive
-r

Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix.

La commande ci-dessous importe les métadonnées pour la dernière version du paquet HTTP Haskell sans inclure les dépendances de test et en spécifiant la valeur du drapeau ‘network-uri’ comme false :

guix import hackage -t -e "'((\"network-uri\" . false))" HTTP

Une version spécifique du paquet peut éventuellement être spécifiée en faisant suivre le nom du paquet par un arobase et un numéro de version comme dans l’exemple suivant :

guix import hackage mtl@2.1.3.1
stackage

L’importateur stackage est une enveloppe autour de l’importateur hackage. Il prend un nom de paquet, recherche la version incluse dans une version au support étendu (LTS) de Stackage et utilise l’importateur hackage pour récupérer les métadonnées. Remarquez que c’est à vous de choisir une version LTS compatible avec le compilateur GHC utilisé par Guix.

Les options spécifiques sont :

--no-test-dependencies
-t

N’inclut pas les dépendances requises uniquement par les suites de tests.

--lts-version=version
-l version

version est la version LTS désirée. Si elle est omise, la dernière version est utilisée.

--recursive
-r

Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix.

La commande ci-dessous importe les métadonnées pour le paquet HTTP Haskell inclus dans la version 7.18 de LTS Stackage :

guix import stackage --lts-version=7.18 HTTP
elpa

Importe les métadonnées du dépôt de paquets ELPA (Emacs Lisp Package Archive) (voir Packages dans The GNU Emacs Manual).

Les options spécifiques sont :

--archive=repo
-a repo

repo identifie le dépôt d’archive depuis lequel récupérer les informations. Actuellement les dépôts supportés et leurs identifiants sont :

  • - GNU, qu’on peut choisir avec l’identifiant gnu. C’est la valeur par défaut.

    Les paquets de elpa.gnu.org avec l’une des clefs contenues dans le porte-clef GnuPG share/emacs/25.1/etc/package-keyring.gpg (ou similaire) dans le paquet emacs (voir ELPA package signatures dans The GNU Emacs Manual).

  • - MELPA-Stable, qu’on peut sélectionner avec l’identifiant melpa-stable.
  • - MELPA, qu’on peut sélectionner avec l’identifiant melpa.
--recursive
-r

Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix.

crate

Importer les métadonnées du dépôt de paquets Rust crates.io crates.io, comme dans cet exemple :

guix import crate blake2-rfc

L’importeur crate vous permet aussi de spécifier une version de chaînes de caractères :

guix import crate constant-time-eq@0.1.0

Les options supplémentaires comprennent :

--recursive
-r

Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix.

opam

Importe les métadonnées du répertoire de paquets OPAM utilisé par la communauté OCaml.

Les options supplémentaires comprennent :

--recursive
-r

Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix.

--repo

Select the given repository (a repository name). Possible values include:

  • opam, the default opam repository,
  • coq or coq-released, the stable repository for coq packages,
  • coq-core-dev, the repository that contains development versions of coq,
  • coq-extra-dev, the repository that contains development versions of coq packages.

La structure du code de guix import est modulaire. Il serait utile d’avoir plus d’importateurs pour d’autres formats de paquets et votre aide est la bienvenue sur ce sujet (voir Contribuer).


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.6 Invoquer guix refresh

La commande guix refresh s’adresse avant tout aux personnes qui développent la distribution logicielle GNU. Par défaut, elle rapporte les paquets fournis par la distribution qui sont en retard par rapport aux dernières versions disponibles en amont, comme ceci :

$ guix refresh
gnu/packages/gettext.scm:29:13: gettext serait mis à jour de 0.18.1.1 à 0.18.2.1
gnu/packages/glib.scm:77:12: glib serait mis à jour de 2.34.3 à 2.37.0

On peut aussi spécifier des paquets à prendre en compte, auquel cas un avertissement est émis pour les paquets qui ne sont pas mis à jour :

$ guix refresh coreutils guile guile-ssh
gnu/packages/ssh.scm:205:2 : avertissement : aucun gestionnaire de mise à jour pour guile-ssh
gnu/packages/guile.scm:136:12 : guile serait mis à jour de 2.0.12 à 2.0.13

guix refresh navigue le dépôt amont de chaque paquet et détermine le numéro de version le plus élevé parmi les versions publiées. La commande sait comment mettre à jour certains types de paquets : les paquets GNU, les paquets ELPA, etc. — voir la documentation pour --type ci-dessous. Il y a beaucoup de paquet cependant pour lesquels il manque une méthode pour déterminer si une nouvelle version est disponible en amont. Cependant, le mécanisme est extensible, alors n’hésitez pas à nous contacter pour ajouter une nouvelle méthode !

--recursive

Considère les paquets spécifiés et tous les paquets dont ils dépendent.

$ guix refresh --recursive coreutils
gnu/packages/acl.scm:35:2: warning: no updater for acl
gnu/packages/m4.scm:30:12: info: 1.4.18 is already the latest version of m4
gnu/packages/xml.scm:68:2: warning: no updater for expat
gnu/packages/multiprecision.scm:40:12: info: 6.1.2 is already the latest version of gmp
…

Parfois les noms en amont diffèrent du nom de paquet utilisé par Guix et guix refresh a besoin d’un peu d’aide. La plupart des gestionnaires de mise à jour honorent la propriété upstream-name dans les définitions de paquets, ce qui peut être utilisé à cette fin :

(define-public network-manager
  (package
    (name "network-manager")
    ;; …
    (properties '((upstream-name . "NetworkManager")))))

Quand l’option --update est utilisée, elle modifie les fichiers sources de la distribution pour mettre à jour les numéros de version et les hash de l’archive source de ces recettes de paquets (voir Définition des paquets). Pour ce faire, il télécharge la dernière archive source de chaque paquet et sa signature OpenPGP associée, authentifiant l’archive téléchargée par rapport à sa signature en utilisant gpgv, et enfin calcule son hash—notez que GnuPG doit être installé et dans $PATH ; lancez guix install gnupg si nécessaire.

Quand la clé publique utilisée pour signer l’archive est manquante depuis le trousseau de clés utilisateur·rice, une tentative est faite de la récupérer automatiquement depuis un serveur de clé publique ; en cas de succès, la clé est ajoutée au trousseau de l’utilisateur·rice ; sinon, guix refresh renvoie une erreur.

Les options suivantes sont supportées :

--expression=expr
-e expr

Considérer le paquet évalué par expr.

C’est utile pour précisément se référer à un paquet, comme dans cet exemple :

guix refresh -l -e '(@@ (gnu packages commencement) glibc-final)'

Cette commande liste les dépendances de la libc « finale » (presque tous les paquets).

--update
-u

Met à jour les fichiers source de la distribution (les recettes de paquets) en place. Cette option est généralement utilisée depuis une copie du dépôt git de Guix (voir Lancer Guix avant qu'il ne soit installé) :

$ ./pre-inst-env guix refresh -s non-core -u

Voir Définition des paquets, pour plus d’information sur les définitions des paquets.

--select=[subset]
-s subset

Choisi tous les paquets dans subset, entre core et non-core.

Le sous-ensemble core se réfère à tous les paquets du cœur de la distribution — c.-à-d. les paquets qui sont utilisés pour construire « tout le reste ». Cela comprend GCC, libc, Binutils, Bash, etc. Habituellement, changer l’un de ces paquets dans la distribution implique de reconstruire tous les autres. Ainsi, ces mises à jour sont une nuisance pour les utilisateurs, en terme de temps de compilation et de bande passante utilisés pour effectuer la mise à jour.

Le sous-ensemble non-core se réfère au reste des paquets. C’est habituellement utile dans les cas où une mise à jour des paquets du cœur serait dérangeante.

--manifest=fichier
-m fichier

Select all the packages from the manifest in file. This is useful to check if any packages of the user manifest can be updated.

--type=updater
-t updater

Chois uniquement les paquets pris en charge par updater (éventuellement une liste de gestionnaires de mise à jour séparés par des virgules). Actuellement, updater peut être l’une des valeurs suivantes :

gnu

le gestionnaire de mise à jour pour les paquets GNU ;

savannah

le gestionnaire de mise à jour pour les paquets hébergés sur Savannah ;

gnome

le gestionnaire de mise à jour pour les paquets GNOME ;

kde

le gestionnaire de mise à jour pour les paquets KDE ;

xorg

le gestionnaire de mise à jour pour les paquets X.org ;

kernel.org

le gestionnaire de mise à jour pour les paquets hébergés sur kernel.org ;

elpa

le gestionnaire de mise à jour pour les paquets ELPA ;

cran

le gestionnaire de mise à jour pour les paquets CRAN ;

bioconductor

le gestionnaire de mise à jour pour les paquets Bioconductor ;

cpan

le gestionnaire de mise à jour pour les paquets CPAN ;

pypi

le gestionnaire de mise à jour pour les paquets PyPI.

gem

le gestionnaire de mise à jour pour les paquets RubyGems.

github

le gestionnaire de mise à jour pour les paquets GitHub.

hackage

le gestionnaire de mise à jour pour les paquets Hackage.

stackage

le gestionnaire de mise à jour pour les paquets Stackage.

crate

le gestionnaire de mise à jour pour les paquets Crates.

launchpad

le gestionnaire de mise à jour pour les paquets Launchpad

Par exemple, la commande suivante ne vérifie que les mises à jour des paquets Emacs hébergés sur elpa.gnu.org et les paquets CRAN :

$ guix refresh --type=elpa,cran
gnu/packages/statistics.scm:819:13 : r-testthat serait mis à jour de 0.10.0 à 0.11.0
gnu/packages/emacs.scm:856:13 : emacs-auctex serait mis à jour de 11.88.6 à 11.88.9

En plus, on peut passer à guix refresh un ou plusieurs noms de paquets, comme dans cet exemple :

$ ./pre-inst-env guix refresh -u emacs idutils gcc@4.8

La commande ci-dessus met à jour spécifiquement les paquets emacs et idutils. L’option --select n’aurait aucun effet dans ce cas.

Pour déterminer s’il faut mettre à jour un paquet, il est parfois pratique de savoir quels paquets seraient affectés par la mise à jour pour pouvoir vérifier la compatibilité. Pour cela l’option suivante peut être utilisée avec un ou plusieurs noms de paquets passés à guix refresh :

--list-updaters
-L

Liste les gestionnaires de mises à jour disponibles et quitte (voir --type ci-dessus).

Pour chaque gestionnaire, affiche le pourcentage de paquets qu’il couvre ; à la fin, affiche le pourcentage de paquets couverts par tous les gestionnaires.

--list-dependent
-l

Liste les paquets de plus haut-niveau qui devraient être reconstruits après la mise à jour d’un ou plusieurs paquets.

Voir le type reverse-package de guix graph, pour des informations sur la manière de visualiser la liste des paquets dépendant d’un autre.

Sachez que l’option --list-dependent n’a qu’une approche approximative sur les reconstructions qui seraient nécessaires à la suite d’une mise à jour. D’autres reconstructions peuvent être nécessaires dans certaines circonstances.

$ guix refresh --list-dependent flex
Building the following 120 packages would ensure 213 dependent packages are rebuilt:
hop@2.4.0 geiser@0.4 notmuch@0.18 mu@0.9.9.5 cflow@1.4 idutils@4.6 …

La commande ci-dessus liste un ensemble de paquets qui peuvent être construits pour vérifier la compatibilité d’une mise à jour de flex.

--list-transitive

Lister tous les paquets dont un paquet ou plus dépendent.

$ guix refresh --list-transitive flex
flex@2.6.4 depends on the following 25 packages: perl@5.28.0 help2man@1.47.6
bison@3.0.5 indent@2.2.10 tar@1.30 gzip@1.9 bzip2@1.0.6 xz@5.2.4 file@5.33 …

La commande ci-dessus liste un ensemble de paquets qui, lorsqu’ils sont modifiés, causent la reconstruction de flex.

Les options suivante peuvent être utilisées pour personnaliser les opérations avec GnuPG :

--gpg=commande

Utilise commande comme la commande de GnuPG 2.x. commande est recherchée dans PATH.

--keyring=fichier

Utilise fichier comme porte-clefs pour les clefs amont. fichier doit être dans le format keybox. Les fichiers Keybox ont d’habitude un nom qui fini par .kbx et GNU Privacy Guard (GPG) peut manipuler ces fichiers (voir kbxutil dans Using the Privacy Guard, pour plus d’informations sur un outil pour manipuler des fichiers keybox).

Lorsque cette option est omise, guix refresh utilise ~/.config/guix/upstream/trustedkeys.kbx comme trousseau pour les clés de signature en amont. Les signatures OpenPGP sont vérifiées avec ces clés ; les clés manquantes sont aussi téléchargées dans ce trousseau (voir --key-download plus bas).

Vous pouvez exporter les clefs de votre porte-clefs GPG par défaut dans un fichier keybox avec une commande telle que :

gpg --export rms@gnu.org | kbxutil --import-openpgp >> mykeyring.kbx

De même, vous pouvez récupérer des clefs dans un fichier keybox spécifique comme ceci :

gpg --no-default-keyring --keyring mykeyring.kbx \
  --recv-keys 3CE464558A84FDC69DB40CFB090B11993D9AEBB5

--keyring dans Using the GNU Privacy Guard pour plus d’informations sur l’option --keyring de GPG.

--key-download=politique

Gère les clefs OpenPGP manquantes d’après la politique, qui peut être l’une des suivantes :

always

Toujours télécharger les clefs manquantes depuis un serveur de clefs et les ajouter au porte-clefs de l’utilisateur.

never

Ne jamais essayer de télécharger les clefs OpenPGP manquante. Quitter à la place.

interactive

Lorsqu’on rencontre un paquet signé par une clef OpenPGP inconnue, demander à l’utilisateur s’il souhaite la télécharger ou non. C’est le comportement par défaut.

--key-server=host

Utiliser host comme serveur de clefs OpenPGP lors de l’importe d’une clef publique.

--load-path=répertoire

Ajoute répertoire au début du chemin de recherche de module de paquets (voir Modules de paquets).

Cela permet à des utilisateurs de définir leur propres paquets et les rendre disponibles aux outils en ligne de commande.

Le gestionnaire de mises à jour github utilise GitHub API pour faire des requêtes sur les nouvelles versions. Lorsqu’elle est utilisé de manière répétée, par exemple lorsque vous vérifiez tous les paquets, GitHub finira par refuser de répondre à d’autres requêtes de l’API. Par défaut 60 requêtes à l’heure sont autorisées, et une vérification complète de tous les paquets GitHub dans Guix demande bien plus que celà. L’authentification avec GitHub à travers l’utilisation d’un jeton d’API lève ces limites. Pour utiliser un jeton de l’API, initialisez la variable d’environnement GUIX_GITHUB_TOKEN avec un jeton que vous vous serez procuré sur https://github.com/settings/tokens ou autrement.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.7 Invoquer guix lint

La commande guix lint est conçue pour aider les développeur·euse·s à éviter des erreurs communes et à utiliser un style cohérent lors de l’écriture de recettes de paquets. Elle lance des vérifications sur un ensemble de paquets donnés pour trouver des erreurs communes dans leur définition. Les vérifieurs disponibles comprennent (voir --list-checkers pour une liste complète) :

synopsis
description

Vérifie certaines règles typographiques et stylistiques dans les descriptions et les synopsis.

inputs-should-be-native

Identifie les entrées qui devraient sans doute plutôt être des entrées natives.

source
home-page
mirror-url
github-url
source-file-name

Probe home-page and source URLs and report those that are invalid. Suggest a mirror:// URL when applicable. If the source URL redirects to a GitHub URL, recommend usage of the GitHub URL. Check that the source file name is meaningful, e.g. is not just a version number or “git-checkout”, without a declared file-name (voir référence des origines).

source-unstable-tarball

Analyse l’URL source pour déterminer si une archive de GitHub est autogénérée ou s’il s’agit d’une archive de publication. Malheureusement les archives autogénérées de GitHub sont parfois régénérées.

dérivation

Vérifiez que la dérivation des paquets donnés peut être calculée avec succès pour tous les systèmes pris en charge (voir Dérivations).

profile-collisions

Vérifiez si l’installation des paquets donnés dans un profil risque d’entraîner des collisions. Des collisions se produisent lorsque plusieurs paquets portant le même nom mais avec une version différente ou un nom de fichier de stockage différent sont propagés. Voir propagated-inputs, pour plus d’informations sur les entrées propagées.

archivage

Vérifie si le code source du paquet est archivé à Software Heritage.

Lorsque le code source non archivé provient d’un système de contrôle de version (VCS)—par exemple, il est obtenu avec git-fetch, envoyez au Software Heritage une requête « save » afin qu’il l’archive éventuellement. Cela garantit que le code source restera disponible à long terme et que Guix peut se retourner vers le Software Heritage si le code source disparaît de son hôte d’origine. L’état des demandes récentes de « sauvegarde » peut être consulté en ligne.

Quand le code source est une archive obtenue avec url-fetch, celà affiche simplement un message quand il n’est pas archivé. Au moment où nous écrivons ces lignes, le Software Heritage n’autorise pas les demandes de sauvegarde d’archives arbitraires ; nous travaillons sur les moyens de garantir que le code source non-VCS soit également archivé.

Software Heritage limits the request rate per IP address. Quand la limite est atteinte, guix lint affiche un message et le vérificateur archival arrête de faire quoi que ce soit jusqu’à ce que cette limite soit réinitialisée.

cve

Rapporte les vulnérabilités connues trouvées dans les bases de données CVE (Common Vulnerabilities and Exposures) de l’année en cours et de l’année précédente published by the US NIST.

Pour voir les informations sur une vulnérabilité en particulier, visitez les pages :

CVE-ANNÉE-ABCD est l’identifiant CVE — p. ex. CVE-2015-7554.

On peut spécifier dans les recettes des paquets le nom Common Platform Enumeration (CPE) et la version du paquet s’ils diffèrent du nom et de la version que Guix utilise, comme dans cet exemple :

(package
  (name "grub")
  ;; …
  ;; CPE nomme ce paquet "grub2".
  (properties '((cpe-name . "grub2")
                (cpe-version . "2.3"))))

Certaines entrées dans la base de données CVE ne spécifient pas la version du paquet auquel elles s’appliquent et lui restera donc attachée pour toujours. Les développeur·euse·s qui trouvent des alertes CVE et ont vérifié qu’elles peuvent être ignorées peuvent les déclarer comme dans cet exemple :

(package
  (name "t1lib")
  ;; …
  ;; Ces CVE ne s'appliquent plus et peuvent être ignorée sans problème.
  (properties `((lint-hidden-cve . ("CVE-2011-0433"
                                    "CVE-2011-1553"
                                    "CVE-2011-1554"
                                    "CVE-2011-5244")))))
formatting

Avertit de problèmes de formatage du code source évidents : des espaces en fin de ligne, des tabulations, etc.

La syntaxe générale est :

guix lint options package

Si aucun paquet n’est donné par la ligne de commande, tous les paquets seront vérifiés. Les options peuvent contenir aucune ou plus des options suivantes :

--list-checkers
-l

Liste et décrit tous les vérificateurs disponibles qui seront lancés sur les paquets puis quitte.

--checkers
-c

N’active que les vérificateurs spécifiés dans une liste de noms séparés par des virgules parmi la liste renvoyée par --list-checkers.

--exclude
-x

Ne désactive que les vérifications spécifiés dans une liste de noms séparés par des virgules, en utilisant les noms de --list-checkers.

--no-network
-n

N’active que les vérificateurs qui ne dépendent pas d’un accès réseau.

--load-path=répertoire
-L répertoire

Ajoute répertoire au début du chemin de recherche de module de paquets (voir Modules de paquets).

Cela permet à des utilisateurs de définir leur propres paquets et les rendre disponibles aux outils en ligne de commande.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.8 Invoquer guix size

La commande guix size aide à dresser un profil de l’utilisation de l’espace disque par les paquets. Il est facile de négliger l’impact d’une dépendance supplémentaire ajoutée à un paquet, ou l’impact de l’utilisation d’une sortie unique pour un paquet qui pourrait être facilement séparé (voir Des paquets avec plusieurs résultats). Ce sont ces problèmes que guix size peut typiquement mettre en valeur.

On peut passer un ou plusieurs spécifications de paquets à la commande, comme gcc@4.8 ou guile:debug, ou un nom de fichier dans le dépôt. Regardez cet exemple :

$ guix size coreutils
store item                               total    self
/gnu/store/…-gcc-5.5.0-lib           60.4    30.1  38.1%
/gnu/store/…-glibc-2.27              30.3    28.8  36.6%
/gnu/store/…-coreutils-8.28          78.9    15.0  19.0%
/gnu/store/…-gmp-6.1.2               63.1     2.7   3.4%
/gnu/store/…-bash-static-4.4.12       1.5     1.5   1.9%
/gnu/store/…-acl-2.2.52              61.1     0.4   0.5%
/gnu/store/…-attr-2.4.47             60.6     0.2   0.3%
/gnu/store/…-libcap-2.25             60.5     0.2   0.2%
total: 78.9 MiB

Les éléments du dépôt listés ici constituent la clôture transitive de Coreutils — c.-à-d. Coreutils et toutes ses dépendances, récursivement — comme ce qui serait renvoyé par :

$ guix gc -R /gnu/store/…-coreutils-8.23

Ici, la sortie possède trois colonnes à côté de chaque élément du dépôt. La première colonne, nommée « total », montre la taille en mébioctet (Mio) de la clôture de l’élément du dépôt — c’est-à-dire sa propre taille plus la taille de ses dépendances. La colonne suivante, nommée « lui-même », montre la taille de l’élément lui-même. La dernière colonne montre le ration de la taille de l’élément lui-même par rapport à celle de tous les éléments montrés.

Dans cet exemple, on voit que la clôture de Coreutils pèse 79 Mio, dont la plupart est dû à la libc et aux bibliothèques à l’exécution de GCC (ce n’est pas un problème en soit que la libc et les bibliothèques de GCC représentent une grande part de la clôture parce qu’elles sont toujours disponibles sur le système de toute façon).

Comme la commande accepte également les noms de fichiers de dépôt, il est facile d’évaluer la taille d’un résultat de construction :

guix size $(guix system build config.scm)

Lorsque les paquets passés à guix size sont disponibles dans le dépôt22, guix size demande au démon de déterminer ses dépendances, et mesure sa taille dans le dépôt, comme avec du -ms --apparent-size (voir du invocation dans GNU Coreutils).

Lorsque les paquets donnés ne sont pas dans le dépôt, guix size rapporte les informations en se basant sur les substituts disponibles (voir Substituts). Cela permet de profiler l’utilisation du disque des éléments du dépôt même s’ils ne sont pas sur le disque, mais disponibles à distance.

Vous pouvez aussi spécifier plusieurs noms de paquets :

$ guix size coreutils grep sed bash
store item                               total    self
/gnu/store/…-coreutils-8.24          77.8    13.8  13.4%
/gnu/store/…-grep-2.22               73.1     0.8   0.8%
/gnu/store/…-bash-4.3.42             72.3     4.7   4.6%
/gnu/store/…-readline-6.3            67.6     1.2   1.2%
…
total: 102.3 MiB

Dans cet exemple on voit que la combinaison des quatre paquets prend 102.3 Mio en tout, ce qui est bien moins que la somme des clôtures puisqu’ils ont beaucoup de dépendances en commun.

En regardant le profil renvoyé par guix size, vous pouvez vous demander pourquoi un paquet donné apparaît dans le profil. Pour le comprendre, vous pouvez utiliser guix graph --path -t references pour afficher le chemin le plus court entre les deux paquets (voir Invoquer guix graph).

Les options disponibles sont :

--substitute-urls=urls

Utilise les informations de substituts de urls. Voir the same option for guix build.

--sort=clef

Trie les lignes en fonction de la clef, l’une des options suivantes :

self

la taille de chaque élément (par défaut) ;

closure

la taille totale de la clôture de l’élément.

--map-file=fichier

Écrit un schéma de l’utilisation du disque au format PNG dans fichier.

Pour l’exemple au-dessus, le schéma ressemble à ceci :

schéma de l’utilisation du disque de
Coreutils produit par guix size

Cette option requiert l’installation de Guile-Charting et qu’il soit visible dans le chemin de recherche des modules Guile. Lorsque ce n’est pas le cas, guix size plante en essayant de le charger.

--system=système
-s système

Considère les paquets pour système — p. ex. x86_64-linux.

--load-path=répertoire
-L répertoire

Ajoute répertoire au début du chemin de recherche de module de paquets (voir Modules de paquets).

Cela permet à des utilisateurs de définir leur propres paquets et les rendre disponibles aux outils en ligne de commande.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.9 Invoque guix graph

Packages and their dependencies form a graph, specifically a directed acyclic graph (DAG). It can quickly become difficult to have a mental model of the package DAG, so the guix graph command provides a visual representation of the DAG. By default, guix graph emits a DAG representation in the input format of Graphviz, so its output can be passed directly to the dot command of Graphviz. It can also emit an HTML page with embedded JavaScript code to display a “chord diagram” in a Web browser, using the d3.js library, or emit Cypher queries to construct a graph in a graph database supporting the openCypher query language. With --path, it simply displays the shortest path between two packages. The general syntax is:

guix graph options paquet

Par exemple, la commande suivante génère un fichier PDF représentant le DAG du paquet pour GNU Core Utilities, qui montre ses dépendances à la compilation :

guix graph coreutils | dot -Tpdf > dag.pdf

La sortie ressemble à ceci :

Graphe de dépendance de GNU Coreutils

Joli petit graphe, non ?

Vous pouvez trouver plus amusant de naviguer dans le graphe interactivement avec xdot (du paquet xdot):

guix graph coreutils | xdot -

Mais il y a plus qu’un seul graphe ! Celui au-dessus est concis : c’est le graphe des objets paquets, en omettant les entrées implicites comme GCC, libc, grep, etc. Il est souvent utile d’avoir ces graphes concis, mais parfois on veut voir plus de détails. guix graph supporte plusieurs types de graphes, qui vous permettent de choisir le niveau de détails :

package

C’est le type par défaut utilisé dans l’exemple plus haut. Il montre le DAG des objets paquets, sans les dépendances implicites. C’est concis, mais omet pas mal de détails.

reverse-package

Cela montre le DAG inversé des paquets. Par exemple :

guix graph --type=reverse-package ocaml

... crée le graphe des paquets qui dépendent explicitement d’OCaml (si vous êtes aussi intéressé·e dans le cas où OCaml représente une dépendance implicite, voir reverse-bag ci-dessous).

Remarquez que pour les paquets du cœur de la distribution, cela crée des graphes énormes. Si vous voulez seulement voir le nombre de paquets qui dépendent d’un paquet donnés, utilisez guix refresh --list-dependent (voir --list-dependent).

bag-emerged

C’est le DAG du paquet, avec les entrées implicites.

Par exemple, la commande suivante :

guix graph --type=bag-emerged coreutils

… montre ce graphe plus gros :

Graphe des dépendances détaillé de
GNU Coreutils

En bas du graphe, on voit toutes les entrées implicites de gnu-build-system (voir gnu-build-system).

Maintenant, remarquez que les dépendances de ces entrées implicites — c’est-à-dire les dépendances de bootstrap (voir Bootstrapping) — ne sont pas affichées, pour rester concis.

bag

Comme bag-emerged mais cette fois inclus toutes les dépendances de bootstrap.

bag-with-origins

Comme bag, mais montre aussi les origines et leurs dépendances.

reverse-bag

Cela montre le DAG inverse des paquets. Contrairement à reverse-package, il montre aussi les dépendance implicites. Par exemple :

guix graph -t reverse-bag dune

… crée le graphe des tous les paquets qui dépendent de Dune, directement ou indirectement. Comme Dune est une dépendance implicite de nombreux paquets via dune-build-system, cela montre un plus grand nombre de paquets, alors que reverse-package en montrerait très peu, voir aucun.

dérivation

C’est la représentation lu plus détaillée : elle montre le DAG des dérivations (voir Dérivations) et des éléments du dépôt. Comparé à la représentation ci-dessus, beaucoup plus de nœuds sont visibles, dont les scripts de construction, les correctifs, les modules Guile, etc.

Pour ce type de graphe, il est aussi possible de passer un nom de fichier .drv à la place d’un nom de paquet, comme dans :

guix graph -t derivation `guix system build -d my-config.scm`
module

C’est le graphe des modules de paquets (voir Modules de paquets). Par exemple, la commande suivante montre le graphe des modules de paquets qui définissent le paquet guile :

guix graph -t module guile | xdot -

Tous les types ci-dessus correspondent aux dépendances à la construction. Le type de graphe suivant représente les dépendances à l’exécution :

references

C’est le graphe des references d’une sortie d’un paquet, telles que renvoyées par guix gc --references (voir Invoquer guix gc).

Si la sortie du paquet donnée n’est pas disponible dans le dépôt, guix graph essayera d’obtenir les informations sur les dépendances à travers les substituts.

Vous pouvez aussi passer un nom de fichier du dépôt plutôt qu’un nom de paquet. Par exemple, la commande ci-dessous produit le graphe des références de votre profile (qui peut être gros !) :

guix graph -t references `readlink -f ~/.guix-profile`
referrers

C’est le graphe des référents d’un élément du dépôt, tels que renvoyés par guix gc --referrers (voir Invoquer guix gc).

Cela repose exclusivement sur les informations de votre dépôt. Par exemple, supposons que Inkscape est actuellement disponible dans 10 profils sur votre machine ; guix graph -t referrers inkscape montrera le graphe dont la racine est Inkscape avec 10 profils qui y sont liés.

Cela peut aider à déterminer ce qui empêche un élément du dépôt d’être glané.

Souvent, le graphe du paquet qui vous intéresse ne tient pas sur votre écran, et de toute façon tout ce que vous voulez savoir c’est pourquoi ce paquet dépend en fait d’un paquet apparemment sans rapport. L’option --path indique à guix graph d’afficher le chemin le plus court entre deux paquets (ou dérivations, ou éléments du dépôt, etc.) :

$ guix graph --path emacs libunistring
emacs@26.3
mailutils@3.9
libunistring@0.9.10
$ guix graph --path -t derivation emacs libunistring
/gnu/store/…-emacs-26.3.drv
/gnu/store/…-mailutils-3.9.drv
/gnu/store/…-libunistring-0.9.10.drv
$ guix graph --path -t references emacs libunistring
/gnu/store/…-emacs-26.3
/gnu/store/…-libidn2-2.2.0
/gnu/store/…-libunistring-0.9.10

Les options disponibles sont les suivante :

--type=type
-t type

Produit un graphe en sortie de type typetype doit être l’un des types au-dessus.

--list-types

Liste les types de graphes supportés.

--backend=moteur
-b moteur

Produit un graphe avec le moteur choisi.

--list-backends

Liste les moteurs de graphes supportés.

Actuellement les moteurs disponibles sont Graphviz et d3.js.

--path

Affiche le chemin le plus court entre deux nœuds du type spécifié par --type. L’exemple ci-dessous montre le chemin le plus court entre libreoffice et llvm correspondant aux références de libreoffice:

$ guix graph --path -t references libreoffice llvm
/gnu/store/…-libreoffice-6.4.2.2
/gnu/store/…-libepoxy-1.5.4
/gnu/store/…-mesa-19.3.4
/gnu/store/…-llvm-9.0.1
--expression=expr
-e expr

Considérer le paquet évalué par expr.

C’est utile pour précisément se référer à un paquet, comme dans cet exemple :

guix graph -e '(@@ (gnu packages commencement) gnu-make-final)'
--system=système
-s système

Affiche le graphe pour système — p. ex. i686-linux.

Le graphe de dépendance des paquets est la plupart du temps indépendant de l’architecture, mais il y a quelques parties qui dépendent de l’architecture que cette option vous permet de visualiser.

--load-path=répertoire
-L répertoire

Ajoute répertoire au début du chemin de recherche de module de paquets (voir Modules de paquets).

Cela permet à des utilisateurs de définir leur propres paquets et les rendre disponibles aux outils en ligne de commande.

En plus de celà, guix graph prend en charge toutes les options habituelles de transformation des paquets (voir Options de transformation de paquets). Il est ainsi facile de voir l’effet d’une transformation de réécriture de graphe telle que --with-input. Par exemple, la commande ci-dessous produit le graphe de git une fois que openssl a été remplacé par libressl partout dans le graphe :

guix graph git --with-input=openssl=libressl

Tant de possibilités, tant de plaisir !


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.10 Invoquer guix publish

Le but de guix publish est de vous permettre de partager facilement votre dépôt avec d’autres personnes qui peuvent ensuite l’utiliser comme serveur de substituts (voir Substituts).

Lorsque guix publish est lancé, il crée un serveur HTTP qui permet à n’importe qui avec un accès réseau d’y récupérer des substituts. Cela signifie que toutes les machines qui font tourner Guix peuvent aussi agir comme une ferme de construction, puisque l’interface HTTP est compatible avec Cuirass, le logiciel derrière la ferme de construction ci.guix.gnu.org.

Pour des raisons de sécurité, chaque substitut est signé, ce qui permet aux destinataires de vérifier leur authenticité et leur intégrité (voir Substituts). Parce que guix publish utilise la clé de signature du système, qui n’est lisible que par l’administrateur système, il doit être lancé en root ; l’option --user lui fait abandonner les privilèges de root dès le début.

La pair de clefs pour les signatures doit être générée avant de lancer guix publish, avec guix archive --generate-key (voir Invoquer guix archive).

When the --advertise option is passed, the server advertises its availability on the local network using multicast DNS (mDNS) and DNS service discovery (DNS-SD), currently via Guile-Avahi (voir Using Avahi in Guile Scheme Programs).

La syntaxe générale est :

guix publish options

Lancer guix publish sans arguments supplémentaires lancera un serveur HTTP sur le port 8080 :

guix publish

Une fois qu’un serveur de publication a été autorisé, le démon peut télécharger des substituts à partir de lui. Voir Récupérer des substituts d'autres serveurs.

Par défaut, guix publish compresse les archives à la volée quand il les sert. Ce mode « à la volée » est pratique puisqu’il ne demande aucune configuration et est disponible immédiatement. Cependant, lorsqu’il s’agit de servir beaucoup de clients, nous recommandons d’utiliser l’option --cache, qui active le cache des archives avant de les envoyer aux clients — voir les détails plus bas. La commande guix weather fournit un manière pratique de vérifier ce qu’un serveur fournit (voir Invoquer guix weather).

En bonus, guix publish sert aussi un miroir adressé par le contenu des fichiers source référencées dans les enregistrements origin (voir référence des origines). Par exemple, en supposant que guix publish tourne sur example.org, l’URL suivante renverra le fichier brut hello-2.10.tar.gz avec le hash SHA256 donné (représenté sous le format nix-base32, voir Invoquer guix hash) :

http://example.org/file/hello-2.10.tar.gz/sha256/0ssi1…ndq1i

Évidemment, ces URL ne fonctionnent que pour des fichiers dans le dépôt ; dans les autres cas, elles renvoie une erreur 404 (« Introuvable »).

Les journaux de construction sont disponibles à partir des URL /log comme ceci :

http://example.org/log/gwspk…-guile-2.2.3

Lorsque guix-daemon est configuré pour sauvegarder les journaux de construction compressés, comme c’est le cas par défaut (voir Invoquer guix-daemon), les URL /log renvoient le journal compressé tel-quel, avec une en-tête Content-Type et/ou Content-Encoding appropriée. Nous recommandons de lancer guix-daemon avec --log-compression=gzip parce que les navigateurs web les décompressent automatiquement, ce qui n’est pas le cas avec la compression bzip2.

Les options suivantes sont disponibles :

--port=port
-p port

Écoute les requêtes HTTP sur le port

--listen=hôte

Écoute sur l’interface réseau de hôte. Par défaut, la commande accepte les connexions de n’importe quelle interface.

--user=utilisateur
-u utilisateur

Charge les privilèges de utilisateur le plus vite possible — c.-à-d. une fois que la socket du serveur est ouverte et que la clef de signature a été lue.

--compression[=méthode[:niveau]]
-C [méthode[:niveau]]

Compress data using the given method and level. method is one of lzip, zstd, and gzip; when method is omitted, gzip is used.

Lorsque level est égal à zéro, désactivez la compression. La plage de 1 à 9 correspond à différents niveaux de compression : 1 est le plus rapide, et 9 est le meilleur (gourmand en CPU). Le niveau par défaut est 3.

Usually, lzip compresses noticeably better than gzip for a small increase in CPU usage; see benchmarks on the lzip Web page. However, lzip achieves low decompression throughput (on the order of 50 MiB/s on modern hardware), which can be a bottleneck for someone who downloads over a fast network connection.

The compression ratio of zstd is between that of lzip and that of gzip; its main advantage is a high decompression speed.

À moins que --cache ne soit utilisé, la compression se fait à la volée et les flux compressés ne sont pas cachés. Ainsi, pour réduire la charge sur la machine qui fait tourner guix publish, c’est une bonne idée de choisir un niveau de compression faible, de lancer guix publish derrière un serveur de cache ou d’utiliser --cache. Utilise --cache a l’avantage qu’il permet à guix publish d’ajouter l’en-tête HTTP Content-Length à sa réponse.

Cette option peut être répétée, auquel cas chaque substitut est compressé en utilisant toutes les méthodes sélectionnées, et toutes sont annoncées. Cette option est utile lorsque les utilisateur·rice·s ne supportent pas toutes les méthodes de compression : il·elle·s peuvent sélectionner celle qu’elles supportent.

--cache=répertoire
-c répertoire

Cache les archives et les métadonnées (les URL .narinfo) dans répertoire et ne sert que les archives dans ce cache.

Lorsque cette option est omise, les archives et les métadonnées sont crées à la volée. Cela réduit la bande passante disponible, surtout quand la compression est activée puisqu’elle pourrait être limitée par le CPU. Un autre inconvénient au mode par défaut est que la taille des archives n’est pas connue à l’avance, donc guix publish n’ajoute pas l’en-tête Content-Length à ses réponses, ce qui empêche les clients de savoir la quantité de données à télécharger.

À l’inverse, lorsque --cache est utilisée, la première requête pour un élément du dépôt (via une URL .narinfo) déclenche une tache de fond pour créer l’archive — en calculant son .narinfo et en compressant l’archive au besoin. Une fois l’archive en cache dans répertoire, les requêtes suivantes réussissent et sont servies directement depuis le cache, ce qui garanti que les clients ont la meilleure bande passante possible.

Cette première requête .narinfo renvoie quand même 200, si l’élément du dépôt est « assez petit », sous la limite de contournement du cache — voir --cache-bypass-threshold plus bas. De cette manière, les clients n’ont pas besoin d’attendre que l’archive soit prête. Pour les éléments plus gros, la première requête .narinfo renvoie 404, ce qui signifie que les clients doivent attendre jusqu’à ce que l’archive soit prête.

Le processus de création est effectué par des threads de travail. Par défaut, un thread par cœur du CPU est créé, mais cela peut être personnalisé. Voir --workers plus bas.

Lorsque l’option --ttl est utilisée, les entrées cachées sont automatiquement supprimées lorsqu’elles expirent.

--workers=N

Lorsque --cache est utilisée, demande l’allocation de N thread de travail pour créer les archives.

--ttl=ttl

Produit des en-têtes HTTP Cache-Control qui expriment une durée de vie (TTL) de ttl. ttl peut dénoter une durée : 5d signifie 5 jours, 1m signifie un mois, etc.

Cela permet au Guix de l’utilisateur de garder les informations en cache pendant ttl. Cependant, remarquez que guix publish ne garanti pas lui-même que les éléments du dépôt qu’il fournit seront toujours disponible pendant la durée ttl.

En plus, lorsque --cache est utilisée, les entrées cachées qui n’ont pas été demandé depuis ttl et n’ont pas d’élément correspondant dans le dépôt peuvent être supprimées.

--cache-bypass-threshold=taille

Avec --cache, les éléments du dépôt plus petits que taille sont immédiatement disponibles, même s’ils ne sont pas en cache. taille est une taille en octets, ou peut utiliser un suffixe comme M pour les mégaoctets, etc. La valeur par défaut est 10M.

Le « contournement du cache » vous permet de réduire le délai de publication pour les clients au prix d’utilisation accrue des I/O et du CPU sur le serveur : en fonction des accès clients, ces éléments peuvent être créés plusieurs fois avant qu’une copie ne soit disponible dans le cache.

Augmenter la limite peut être utile pour les sites qui ont peu d’utilisateurs, ou pour garantir que les utilisateurs reçoivent les substituts même pour les éléments qui ne sont pas populaires.

--nar-path=chemin

Utilise chemin comme préfixe des URL de fichier « nar » (voir normalized archives).

Par défaut, les nars sont présents à l’URL comme /nar/gzip/…-coreutils-8.25. Cette option vous permet de changer la partie /nar en chemin.

--public-key=fichier
--private-key=fichier

Utilise les fichiers spécifiques comme pair de clefs utilisées pour signer les éléments avant de les publier.

Les fichiers doivent correspondre à la même pair de clefs (la clef privée est utilisée pour signer et la clef publique est seulement ajouté aux métadonnées de la signature). Ils doivent contenir les clefs dans le format s-expression canonique produit par guix archive --generate-key (voir Invoquer guix archive). Par défaut, /etc/guix/signing-key.pub et /etc/guix/signing-key.sec sont utilisés.

--repl[=port]
-r [port]

Crée un serveur REPL Guile (voir REPL Servers dans GNU Guile Reference Manual) sur pport (37146 par défaut). C’est surtout utile pour déboguer un serveur guix publish qui tourne.

Activer guix publish sur un système Guix est vraiment une seule ligne : instanciez simplement un service guix-publish-service-type dans le champs services de votre déclaration operating-system (voir guix-publish-service-type).

Si vous utilisez plutôt Guix sur une « distro étrangère », suivez ces instructions :


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.11 Invoquer guix challenge

Est-ce que les binaires fournis par ce serveur correspondent réellement au code source qu’il dit avoir construit ? Est-ce que le processus de construction d’un paquet est déterministe ? Ce sont les question auxquelles la commande guix challenge essaye de répondre.

La première question est évidemment importante : avant d’utiliser un serveur de substituts (voir Substituts), il vaut mieux vérifier qu’il fournit les bons binaires et donc le défier. La deuxième est ce qui permet la première : si les constructions des paquets sont déterministes alors des constructions indépendantes du paquet devraient donner le même résultat, bit à bit ; si un serveur fournit un binaire différent de celui obtenu localement, il peut être soit corrompu, soit malveillant.

On sait que le hash qui apparaît dans /gnu/store est le hash de toutes les entrées du processus qui construit le fichier ou le répertoire — les compilateurs, les bibliothèques, les scripts de construction, etc. (voir Introduction). En supposant que les processus de construction sont déterministes, un nom de fichier dans le dépôt devrait correspondre exactement à une sortie de construction. guix challenge vérifie si il y a bien effectivement une seule correspondance en comparant les sorties de plusieurs constructions indépendantes d’un élément du dépôt donné.

La sortie de la commande ressemble à :

$ guix challenge --substitute-urls="https://ci.guix.gnu.org https://guix.example.org"
mise à jour de la liste des substituts depuis 'https://ci.guix.gnu.org'... 100.0%
mise à jour de la liste des substituts depuis 'https://guix.example.org'... 100.0%
le contenu de /gnu/store/…-openssl-1.0.2d diffère :
  empreinte locale : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q
  https://ci.guix.gnu.org/nar/…-openssl-1.0.2d : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q
  https://guix.example.org/nar/…-openssl-1.0.2d : 1zy4fmaaqcnjrzzajkdn3f5gmjk754b43qkq47llbyak9z0qjyim
  fichiers différents :
    /lib/libcrypto.so.1.1
    /lib/libssl.so.1.1
le contenu de /gnu/store/…-git-2.5.0 diffère :
  empreinte locale : 00p3bmryhjxrhpn2gxs2fy0a15lnip05l97205pgbk5ra395hyha
  https://ci.guix.gnu.org/nar/…-git-2.5.0 : 069nb85bv4d4a6slrwjdy8v1cn4cwspm3kdbmyb81d6zckj3nq9f
  https://guix.example.org/nar/…-git-2.5.0 : 0mdqa9w1p6cmli6976v4wi0sw9r4p5prkj7lzfd1877wk11c9c73
  fichier différent :
    /libexec/git-core/git-fsck

le contenu de /gnu/store/…-pius-2.1.1 diffère :
  empreinte locale : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax
  https://ci.guix.gnu.org/nar/…-pius-2.1.1 : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax
  https://guix.example.org/nar/…-pius-2.1.1 : 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs
  fichier différent:
    /share/man/man1/pius.1.gz

…

6,406 éléments du dépôt ont été analysés :
  - 4,749 (74.1%) étaient identiques
  - 525 (8.2%) étaient différents
  - 1,132 (17.7%) étaient impossibles à évaluer

Dans cet exemple, guix challenge scanne d’abord le dépôt pour déterminer l’ensemble des dérivations construites localement — en opposition aux éléments qui ont été téléchargées depuis un serveur de substituts — puis demande leur avis à tous les serveurs de substituts. Il rapporte ensuite les éléments du dépôt pour lesquels les serveurs ont obtenu un résultat différent de la construction locale.

Dans l’exemple, guix.example.org obtient toujours une réponse différente. Inversement, ci.guix.gnu.org est d’accord avec les constructions locale, sauf dans le cas de Git. Cela peut indiquer que le processus de construction de Git est non-déterministe, ce qui signifie que sa sortie diffère en fonction de divers choses que Guix ne contrôle pas parfaitement, malgré l’isolation des constructions (voir Fonctionnalités). Les sources les plus communes de non-déterminisme comprennent l’ajout d’horodatage dans les résultats des constructions, l’inclusion de nombres aléatoires et des listes de fichiers ordonnés par numéro d’inœud. Voir https://reproducible-builds.org/docs/, pour plus d’informations.

Pour trouver ce qui ne va pas avec ce binaire Git, l’approche la plus facile est de lancer :

guix challenge git \
  --diff=diffoscope \
  --substitute-urls="https://ci.guix.gnu.org https://guix.example.org"

Celà invoque automatiquement diffoscope, qui affiche des informations détaillées sur les fichiers qui diffèrent.

Autrement, nous pouvons faire quelque chose comme dans ces lignes (voir Invoquer guix archive):

$ wget -q -O - https://ci.guix.gnu.org/nar/lzip/…-git-2.5.0 \
   | lzip -d | guix archive -x /tmp/git
$ diff -ur --no-dereference /gnu/store/…-git.2.5.0 /tmp/git

Cette commande montre les différences entre les fichiers qui résultent de la construction locale et des fichiers qui résultent de la construction sur ci.guix.gnu.org (voir Comparing and Merging Files dans Comparing and Merging Files). La commande diff fonctionne bien avec des fichiers texte. Lorsque des fichiers binaires diffèrent cependant, Diffoscope est une meilleure option. C’est un outil qui aide à visualiser les différences entre toute sorte de fichiers.

Une fois que vous avez fait ce travail, vous pourrez dire si les différences sont dues au non-déterminisme du processus de construction ou à la malhonnêteté du serveur. Nous avons fait beaucoup d’effort pour éliminer les sources de non-déterminisme dans les paquets pour rendre plus facile la vérification des substituts, mais bien sûr, c’est un processus qui n’implique pas que Guix, mais une grande partie de la communauté des logiciels libres. Pendant ce temps, guix challenge est un outil pour aider à corriger le problème.

Si vous écrivez un paquet pour Guix, nous vous encourageons à vérifier si ci.guix.gnu.org et d’autres serveurs de substituts obtiennent le même résultat que vous avec :

$ guix challenge paquet

paquet est une spécification de paquet comme guile@2.0 ou glibc:debug.

La syntaxe générale est :

guix challenge options [paquets…]

Lorsqu’une différence est trouvée entre l’empreinte d’un élément construit localement et celle d’un substitut fourni par un serveur, ou parmi les substituts fournis par différents serveurs, la commande l’affiche comme dans l’exemple ci-dessus et sa valeur de sortie est 2 (les autres valeurs différentes de 0 indiquent d’autres sortes d’erreurs).

L’option qui compte est :

--substitute-urls=urls

Considère urls comme la liste des URL des sources de substituts séparés par des espaces avec lesquels comparer les paquets locaux.

--diff=mode

En cas d’inadéquation, montre les différences en fonction de mode, l’un des :

simple (par défaut)

Montrer la liste des fichiers qui diffèrent.

diffoscope
commande

Invoque Diffoscope, en lui passant deux répertoires dont le contenu ne correspond pas.

Quand command est un nom de fichier absolu, lancez command au lieu de Diffoscope.

none

Ne donnez pas plus de détails sur les différences.

Ainsi, à moins que l’option --diff=none ne soit passée, guix challenge télécharge les éléments du store à partir des serveurs de substitut donnés afin de pouvoir les comparer.

--verbose
-v

Montre des détails sur les correspondances (contenu identique) en plus des informations sur différences.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.12 Invoquer guix copy

La commande guix copy copie des éléments du dépôt d’une machine vers le dépôt d’une autre machine à travers une connexion SSH23. Par exemple, la commande suivante copie le paquet coreutils, le profil utilisateur et toutes leurs dépendances sur hôte, en tant qu’utilisateur utilisateur :

guix copy --to=utilisateur@hôte \
          coreutils `readlink -f ~/.guix-profile`

Si certains éléments à copier sont déjà présents sur hôte, ils ne sont pas envoyés.

La commande ci-dessous récupère libreoffice et gimp depuis hôte, en supposant qu’ils y sont présents :

guix copy --from=hôte libreoffice gimp

La connexion SSH est établie avec le client Guile-SSH, qui set compatible avec OpenSSH : il honore ~/.ssh/known_hosts et ~/.ssh/config et utilise l’agent SSH pour l’authentification.

La clef utilisée pour signer les éléments qui sont envoyés doit être acceptée par la machine distante. De même, la clef utilisée pour la machine distante depuis laquelle vous récupérez des éléments doit être dans /etc/guix/acl pour qu’ils soient acceptés par votre propre démon. Voir Invoquer guix archive, pour plus d’informations sur l’authentification des éléments du dépôt.

La syntaxe générale est :

guix copy [--to=spec|--from=spec] items

Vous devez toujours spécifier l’une des options suivantes :

--to=spec
--from=spec

Spécifie l’hôte où envoyer ou d’où recevoir les éléments. spec doit être une spécification SSH comme example.org, charlie@example.org ou charlie@example.org:2222.

L’option items peut être des noms de paquets, comme gimp ou des éléments du dépôt comme /gnu/store/…-idutils-4.6.

Lorsque vous spécifiez le nom d’un paquet à envoyer, il est d’abord construit au besoin, sauf si l’option --dry-run est spécifiée. Les options de construction communes sont supportées (voir Options de construction communes).


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.13 Invoquer guix container

Remarque : À la version 1.2.0, cet outil est toujours expérimental. L’interface est sujette à changement radicaux dans le futur.

Le but de guix container est de manipuler des processus qui tournent dans un environnement séparé, connus sous le nom de « conteneur », typiquement créés par les commandes guix environment (voir Invoquer guix environment) et guix system container (voir Invoquer guix system).

La syntaxe générale est :

guix container action options

action spécifie les opérations à effectuer avec un conteneur, et options spécifie les arguments spécifiques au contexte pour l’action.

Les actions suivantes sont disponibles :

exec

Exécute une commande dans le contexte d’un conteneur lancé.

La syntaxe est :

guix container exec pid programme arguments

pid spécifie le PID du conteneur lancé. programme spécifie le nom du fichier exécutable dans le système de fichiers racine du conteneur. arguments sont les options supplémentaires à passer à programme.

La commande suivante lance un shell de connexion interactif dans un conteneur Guix System, démarré par guix system container et dont le PID est 9001 :

guix container exec 9001 /run/current-system/profile/bin/bash --login

Remarquez que pid ne peut pas être le processus parent d’un conteneur. Ce doit être le PID 1 du conteneur ou l’un de ses processus fils.


Suivant: , Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.14 Invoquer guix weather

Vous pouvez parfois grogner lorsque les substituts ne sont pas disponibles et que vous devez construire les paquets vous-même (voir Substituts). La commande guix weather rapporte la disponibilité des substituts sur les serveurs spécifiés pour que vous sachiez si vous allez raller aujourd’hui. Cela peut parfois être une information utile pour les utilisateurs, mais elle est surtout utile pour les personnes qui font tourner guix publish (voir Invoquer guix publish).

Voici un exemple :

$ guix weather --substitute-urls=https://guix.example.org
calcul de 5,872 dérivations de paquets pour x86_64-linux…
recherche de 6,128 éléments du dépôt sur https://guix.example.org…
mise à jour de la liste des substituts depuis 'https://guix.example.org'... 100.0%
https://guix.example.org
  43.4% substituts disponibles (2,658 sur 6,128)
  7,032.5 Mo de fichiers nar (compressés)
  19,824.2 Mo sur le disque (décompressés)
  0.030 secondes par requêtes (182.9 secondes au total)
  33.5 requêtes par seconde

  9.8% (342 sur 3,470) des éléments manquants sont dans la queue
  867 constructions dans la queue
      x86_64-linux : 518 (59.7%)
      i686-linux : 221 (25.5%)
      aarch64-linux : 128 (14.8%)
  vitesse de construction : 23.41 constructions par heure
      x86_64-linux : 11.16 constructions par heure
      i686-linux : 6.03 constructions par heure
      aarch64-linux : 6.41 constructions par heure

Comme vous pouvez le voir, elle rapporte le pourcentage des paquets pour lesquels des substituts sont disponibles sur le serveur — indépendamment du fait que les substituts soient activés, et indépendamment du fait que la clef de signature du serveur soit autorisée. Elle rapporte aussi la taille des archives compressées (« nars ») fournies par le serveur, la taille des éléments du dépôt correspondant dans le dépôt (en supposant que la déduplication soit désactivée) et la vitesse du serveur. La deuxième partie donne des statistiques sur l’intégration continue (CI), si le serveur le supporte. En plus, avec l’option --coverage, guix weather peut lister les substituts de paquets « importants » qui font défaut sur le serveur (voir plus bas).

Pour cela, guix weather récupère par HTTP(S) les métadonnées (narinfos de tous les éléments du dépôts pertinents. Comme guix challenge, il ignore les signatures de ces substituts, ce qui n’est pas dangereux puisque la commande ne fait que récupérer des statistiques et n’installe pas ces substituts.

La syntaxe générale est :

guix weather options… [paquets…]

Lorsque packages est omis, guix weather vérifie la disponibilité de substituts pour all les paquets, ou pour ceux spécifiés avec --manifest ; sinon, il ne prend en compte que les paquets spécifiés. Il est également possible d’interroger des types de systèmes spécifiques avec --system. guix weather sort avec un code non nul lorsque la fraction des substituts disponibles est inférieure à 100%.

Les options disponibles sont listées ci-dessous.

--substitute-urls=urls

urls est la liste des URL des serveurs de substituts séparés par des espaces. Lorsque cette option n’est pas renseignée, l’ensemble des serveurs de substituts par défaut est utilisé.

--system=système
-s système

Effectue des requêtes pour les substituts système — p. ex. aarch64-linux. Cette option peut être répétée, auquel cas guix weather demandera les substituts de plusieurs types de systèmes.

--manifest=fichier

Plutôt que de demander des substituts pour tous les paquets, demande uniquement les paquets spécifiés dans fichier. fichier doit contenir un manifeste comme avec l’option -m de guix package (voir Invoquer guix package).

Cette option peut être répétée plusieurs fois, auquel cas les manifestes sont concaténés.

--coverage[=count]
-c [count]

Rapporte la couverture des substituts pour les paquets : liste les paquets avec au moins count autres paquets qui en dépendent (zéro par défaut) pour lesquels il n’y a pas de substitut. Les paquets qui en dépendent ne sont pas listés : si b dépend de a et que a n’a pas de substitut, seul a est listé, même si b n’a habituellement pas de substitut non plus. Le résultat ressemble à cela :

$ guix weather --substitute-urls=https://ci.guix.gnu.org -c 10
calcul de 8 983 dérivations de paquets pour x86_64-linux…
recherche de 9 343 éléments du dépôt sur https://ci.guix.gnu.org…
mise à jour des substituts depuis « https://ci.guix.gnu.org »… 100,0 %
https://ci.guix.gnu.org
  64.7 % des substituts sont disponibles (6,047 sur 9,343)
…
2502 paquets ne sont pas sur « https://ci.guix.gnu.org » pour « x86_64-linux », parmi lesquels :
    58  kcoreaddons@5.49.0      /gnu/store/…-kcoreaddons-5.49.0
    46  qgpgme@1.11.1           /gnu/store/…-qgpgme-1.11.1
    37  perl-http-cookiejar@0.008  /gnu/store/…-perl-http-cookiejar-0.008
    …

What this example shows is that kcoreaddons and presumably the 58 packages that depend on it have no substitutes at ci.guix.gnu.org; likewise for qgpgme and the 46 packages that depend on it.

Si vous êtes un développeur de Guix, ou si vous prenez soin de cette ferme de construction, vous voudrez sans doute inspecter plus finement ces paquets : ils peuvent simplement avoir échoué à la construction.

--display-missing

Afficher la liste des articles du magasin pour lesquels il manque des substituts.


Précédent: , Monter: Utilitaires   [Table des matières][Index]

9.15 Invoquer guix processes

La commande guix processes peut être utile pour les développeur·euse·s ou les personnes qui administrent des systèmes, surtout sur des machines multi-utilisateur·rice et sur les fermes de construction : elle liste les sessions actuelles (les connexions au démon), ainsi que des informations sur les processus en question24. Voici un exemple des informations qu’elle renvoie :

$ sudo guix processes
SessionPID: 19002
ClientPID: 19090
ClientCommand: guix environment --ad-hoc python

SessionPID: 19402
ClientPID: 19367
ClientCommand: guix publish -u guix-publish -p 3000 -C 9 …

SessionPID: 19444
ClientPID: 19419
ClientCommand: cuirass --cache-directory /var/cache/cuirass …
LockHeld: /gnu/store/…-perl-ipc-cmd-0.96.lock
LockHeld: /gnu/store/…-python-six-bootstrap-1.11.0.lock
LockHeld: /gnu/store/…-libjpeg-turbo-2.0.0.lock
ChildPID: 20495
ChildCommand: guix offload x86_64-linux 7200 1 28800
ChildPID: 27733
ChildCommand: guix offload x86_64-linux 7200 1 28800
ChildPID: 27793
ChildCommand: guix offload x86_64-linux 7200 1 28800

Dans cet exemple, on voit que guix-daemon a trois clients directs : guix environment, guix publish et l’outil d’intégration continue Cuirass ; leur identifiant de processus (PID) est donné par le champ ClientPID. Le champ SessionPID fournit le PID du sous-processus guix-daemon de cette session particulière.

The LockHeld fields show which store items are currently locked by this session, which corresponds to store items being built or substituted (the LockHeld field is not displayed when guix processes is not running as root). Last, by looking at the ChildPID and ChildCommand fields, we understand that these three builds are being offloaded (voir Réglages du délestage du démon).

La sortie est dans le format Recutils pour qu’on puisse utiliser la commande recsel pour sélectionner les sessions qui nous intéressent (voir Selection Expressions dans GNU recutils manual). Par exemple, la commande montre la ligne de commande et le PID du client qui effectue la construction d’un paquet Perl :

$ sudo guix processes | \
    recsel -p ClientPID,ClientCommand -e 'LockHeld ~ "perl"'
ClientPID: 19419
ClientCommand: cuirass --cache-directory /var/cache/cuirass …

Additional options are listed below.

--format=format
-f format

Produire la sortie dans le format donné, parmi :

recutils

The default option. It outputs a set of Session recutils records that include each ChildProcess as a field.

normalized

Normalize the output records into record sets (voir Record Sets dans GNU recutils manual). Normalizing into record sets allows joins across record types. The example below lists the PID of each ChildProcess and the associated PID for Session that spawned the ChildProcess where the Session was started using guix build.

$ guix processes --format=normalized | \
    recsel \
    -j Session \
    -t ChildProcess \
    -p Session.PID,PID \
    -e 'Session.ClientCommand ~ "guix build"'
PID: 4435
Session_PID: 4278

PID: 4554
Session_PID: 4278

PID: 4646
Session_PID: 4278

Suivant: , Précédent: , Monter: Top   [Table des matières][Index]

10 Configuration système

Guix System utilise un mécanisme de configuration du système cohérent. On veut dire par là que tous les aspects de la configuration globale du système — comme la disponibilité des services système, la configuration des fuseaux horaires, des paramètres linguistiques et des comptes utilisateurs — sont déclarés à un seul endroit. Une telle configuration système peut être instanciée, c’est-à-dire entrer en vigueur.

L’un des avantages de placer toute la configuration du système sous le contrôle de Guix est de permettre les mises à jour transactionnelles du système ce qui rend possible le fait de revenir en arrière à une instanciation précédent du système, si quelque chose se passait mal avec le nouveau (voir Fonctionnalités). Un autre avantage est de rendre facile la réplication de la même configuration sur plusieurs machines différentes ou à différents moments dans le temps, sans avoir à recourir à des outils d’administrations supplémentaires au-dessus des outils du système.

Cette section décrit ce mécanisme. Tout d’abord nous nous concentrons sur le point de vue de l’administrateur système en expliquant comment le système est configuré et instancié. Ensuite nous montrons comment ce mécanisme peut être étendu, par exemple pour supporter de nouveaux services systèmes.


Suivant: , Monter: Configuration système   [Table des matières][Index]

10.1 Utiliser le système de configuration

Le système d’exploitation est configuré en fournissant une déclaration operating-system dans un fichier qui peut être passé à la command guix system (voir Invoquer guix system). Une configuration simple, avec les services systèmes par défaut, le noyau Linux-Libre par défaut, un disque de RAM initial et un chargeur d’amorçage ressemble à ceci :

;; This is an operating system configuration template
;; for a "bare bones" setup, with no X11 display server.

(use-modules (gnu))
(use-service-modules networking ssh)
(use-package-modules screen ssh)

(operating-system
  (host-name "komputilo")
  (timezone "Europe/Berlin")
  (locale "en_US.utf8")

  ;; Boot in "legacy" BIOS mode, assuming /dev/sdX is the
  ;; target hard disk, and "my-root" is the label of the target
  ;; root file system.
  (bootloader (bootloader-configuration
                (bootloader grub-bootloader)
                (target "/dev/sdX")))
  (file-systems (cons (file-system
                        (device (file-system-label "my-root"))
                        (mount-point "/")
                        (type "ext4"))
                      %base-file-systems))

  ;; This is where user accounts are specified.  The "root"
  ;; account is implicit, and is initially created with the
  ;; empty password.
  (users (cons (user-account
                (name "alice")
                (comment "Bob's sister")
                (group "users")

                ;; Adding the account to the "wheel" group
                ;; makes it a sudoer.  Adding it to "audio"
                ;; and "video" allows the user to play sound
                ;; and access the webcam.
                (supplementary-groups '("wheel"
                                        "audio" "video")))
               %base-user-accounts))

  ;; Globally-installed packages.
  (packages (cons screen %base-packages))

  ;; Add services to the baseline: a DHCP client and
  ;; an SSH server.
  (services (append (list (service dhcp-client-service-type)
                          (service openssh-service-type
                                   (openssh-configuration
                                    (openssh openssh-sans-x)
                                    (port-number 2222))))
                    %base-services)))

Cet exemple devrait se comprendre de lui-même. Certains champs définis ci-dessus, comme host-name et bootloader sont obligatoires. D’autres comme packages et services peuvent être omis auquel cas ils ont une valeur par défaut.

Ci-dessous nous discutons des effets de certains des champs les plus importants (voir référence de système d'exploitation, pour des détails sur tous les champs disponibles) et comment instancier le système d’exploitation avec guix system.

Bootloader

Le champ bootloader décrit la méthode qui sera utilisée pour démarrer votre système. Les machines basées sur les processeurs Intel peuvent démarrer dans l’ancien mode BIOS, comme dans l’exemple au-dessus. Cependant, les machines plus récentes s’appuient sur l’UEFI (Unified Extensible Firmware Interface) pour démarrer. Dans ce cas, le champ bootloader devrait contenir quelque chose comme cela :

(bootloader-configuration
  (bootloader grub-efi-bootloader)
  (target "/boot/efi"))

Voir Configuration du chargeur d'amorçage, pour plus d’informations sur les options de configuration disponibles.

Paquets visibles sur tout le système

Le champ packages liste les paquets qui seront visibles sur tout le système, pour tous les comptes utilisateur·rice·s — c.-à-d. dans la variable d’environnement PATH de tous les utilisateur·rice·s — en plus des profils utilisateur·rice·s (voir Invoquer guix package). La variable %base-packages fournit tous les outils qu’on pourrait attendre pour les taches de base de l’administrateur·rice et de l’utilisateur·rice — dont les GNU Core Utilities, les GNU Networking Utilities, l’éditeur de texte léger GNU Zile, find, grep, etc. L’exemple ci-dessus ajoute GNU Screen à ces paquets, récupéré depuis le module (gnu packages screen) (voir Modules de paquets). Vous pouvez utiliser la syntaxe (list package output) pour ajouter une sortie spécifique d’un paquet :

(use-modules (gnu packages))
(use-modules (gnu packages dns))

(operating-system
  ;; ...
  (packages (cons (list bind "utils")
                  %base-packages)))

Se référer aux paquets par le nom de leur variable, comme bind ci-dessus, a l’avantage d’être sans ambiguïté ; cela permet aussi de se rendre rapidement compte de coquilles quand on a des « variables non liées ». L’inconvénient est qu’on a besoin de savoir dans quel module est défini le paquet, et de modifier la ligne use-package-modules en conséquence. Pour éviter cela, on peut utiliser la procédure specification->package du module (gnu packages), qui renvoie le meilleur paquet pour un nom donné ou un nom et une version :

(use-modules (gnu packages))

(operating-system
  ;; ...
  (packages (append (map specification->package
                         '("tcpdump" "htop" "gnupg@2.0"))
                    %base-packages)))

Services systèmes

Le champ services liste les services système à rendre disponible lorsque le système démarre (voir Services). La déclaration operating-system au-dessus spécifie que, en plus des services de base, on veut que le démon ssh OpenSSH écoute sur le port 2222 (voir openssh-service-type). Sous le capot, openssh-service-type s’arrange pour que sshd soit lancé avec les bonnes options de la ligne de commande, éventuellement en générant des fichiers de configuration (voir Définir des services).

Parfois, plutôt que d’utiliser les services de base tels-quels, on peut vouloir les personnaliser. Pour cela, utilisez modify-services (voir modify-services) pour modifier la liste.

Par exemple, supposons que vous souhaitiez modifier guix-daemon et Mingetty (l’écran de connexion en console) dans la liste %base-services (voir %base-services). Pour cela, vous pouvez écrire ce qui suit dans votre déclaration de système d’exploitation :

(define %my-services
  ;; ma propre liste de services.
  (modify-services %base-services
    (guix-service-type config =>
                       (guix-configuration
                        (inherit config)
                        ;; Récupérer les substituts depuis example.org.
                        (substitute-urls
                          (list "https://example.org/guix"
                                "https://ci.guix.gnu.org"))))
    (mingetty-service-type config =>
                           (mingetty-configuration
                            (inherit config)
                            ;; Connexion automatique en tant que « guest ».
                            (auto-login "guest")))))

(operating-system
  ;; …
  (services %my-services))

Cela modifie la configuration — c.-à-d. les paramètres du service — de l’instance de guix-service-type, et de toutes les instances de mingetty-service-type dans la liste %base-services. Remarquez comment on fait cela : d’abord, on s’arrange pour que la configuration de départ soit liée à l’identifiant config dans body puis on écrit body pour qu’il s’évalue en la configuration désirée. En particulier, remarquez comment on utilise inherit pour créer une nouvelle configuration qui a les même valeurs que l’ancienne configuration, avec seulement quelques modifications.

La configuration pour une utilisation de « bureau » typique, avec une partition racine chiffrée, le serveur d’affichage X11, GNOME et Xfce (les utilisateurs peuvent choisir l’environnement de bureau sur l’écran de connexion en appuyant sur F1), la gestion du réseau, la gestion de l’énergie, et bien plus, ressemblerait à ceci :

;; This is an operating system configuration template
;; for a "desktop" setup with GNOME and Xfce where the
;; root partition is encrypted with LUKS.

(use-modules (gnu) (gnu system nss))
(use-service-modules desktop xorg)
(use-package-modules certs gnome)

(operating-system
  (host-name "antelope")
  (timezone "Europe/Paris")
  (locale "en_US.utf8")

  ;; Choose US English keyboard layout.  The "altgr-intl"
  ;; variant provides dead keys for accented characters.
  (keyboard-layout (keyboard-layout "us" "altgr-intl"))

  ;; Use the UEFI variant of GRUB with the EFI System
  ;; Partition mounted on /boot/efi.
  (bootloader (bootloader-configuration
                (bootloader grub-efi-bootloader)
                (target "/boot/efi")
                (keyboard-layout keyboard-layout)))

  ;; Specify a mapped device for the encrypted root partition.
  ;; The UUID is that returned by 'cryptsetup luksUUID'.
  (mapped-devices
   (list (mapped-device
          (source (uuid "12345678-1234-1234-1234-123456789abc"))
          (target "my-root")
          (type luks-device-mapping))))

  (file-systems (append
                 (list (file-system
                         (device (file-system-label "my-root"))
                         (mount-point "/")
                         (type "ext4")
                         (dependencies mapped-devices))
                       (file-system
                         (device (uuid "1234-ABCD" 'fat))
                         (mount-point "/boot/efi")
                         (type "vfat")))
                 %base-file-systems))

  ;; Create user `bob' with `alice' as its initial password.
  (users (cons (user-account
                (name "bob")
                (comment "Alice's brother")
                (password (crypt "alice" "$6$abc"))
                (group "users")
                (supplementary-groups '("wheel" "netdev"
                                        "audio" "video")))
               %base-user-accounts))

  ;; This is where we specify system-wide packages.
  (packages (append (list
                     ;; for HTTPS access
                     nss-certs
                     ;; for user mounts
                     gvfs)
                    %base-packages))

  ;; Add GNOME and Xfce---we can choose at the log-in screen
  ;; by clicking the gear.  Use the "desktop" services, which
  ;; include the X11 log-in service, networking with
  ;; NetworkManager, and more.
  (services (append (list (service gnome-desktop-service-type)
                          (service xfce-desktop-service-type)
                          (set-xorg-configuration
                           (xorg-configuration
                            (keyboard-layout keyboard-layout))))
                    %desktop-services))

  ;; Allow resolution of '.local' host names with mDNS.
  (name-service-switch %mdns-host-lookup-nss))

Un système graphique avec un choix de gestionnaires de fenêtres légers plutôt que des environnement de bureaux complets ressemblerait à cela :

;; This is an operating system configuration template
;; for a "desktop" setup without full-blown desktop
;; environments.

(use-modules (gnu) (gnu system nss))
(use-service-modules desktop)
(use-package-modules bootloaders certs emacs emacs-xyz ratpoison suckless wm
                     xorg)

(operating-system
  (host-name "antelope")
  (timezone "Europe/Paris")
  (locale "en_US.utf8")

  ;; Use the UEFI variant of GRUB with the EFI System
  ;; Partition mounted on /boot/efi.
  (bootloader (bootloader-configuration
                (bootloader grub-efi-bootloader)
                (target "/boot/efi")))

  ;; Assume the target root file system is labelled "my-root",
  ;; and the EFI System Partition has UUID 1234-ABCD.
  (file-systems (append
                 (list (file-system
                         (device (file-system-label "my-root"))
                         (mount-point "/")
                         (type "ext4"))
                       (file-system
                         (device (uuid "1234-ABCD" 'fat))
                         (mount-point "/boot/efi")
                         (type "vfat")))
                 %base-file-systems))

  (users (cons (user-account
                (name "alice")
                (comment "Bob's sister")
                (group "users")
                (supplementary-groups '("wheel" "netdev"
                                        "audio" "video")))
               %base-user-accounts))

  ;; Add a bunch of window managers; we can choose one at
  ;; the log-in screen with F1.
  (packages (append (list
                     ;; window managers
                     ratpoison i3-wm i3status dmenu
                     emacs emacs-exwm emacs-desktop-environment
                     ;; terminal emulator
                     xterm
                     ;; for HTTPS access
                     nss-certs)
                    %base-packages))

  ;; Use the "desktop" services, which include the X11
  ;; log-in service, networking with NetworkManager, and more.
  (services %desktop-services)

  ;; Allow resolution of '.local' host names with mDNS.
  (name-service-switch %mdns-host-lookup-nss))

Cet exemple se réfère au système de fichier /boot/efi par son UUID, 1234-ABCD. Remplacez cet UUID par le bon UUID de votre système, renvoyé par la commande blkid.

Voir Services de bureaux, pour la liste exacte des services fournis par %desktop-services. Voir Certificats X.509, pour des informations sur le paquet nss-certs utilisé ici.

Encore une fois, %desktop-services n’est qu’une liste d’objets service. Si vous voulez enlever des services de là, vous pouvez le faire avec des procédures pour les listes (voir SRFI-1 Filtering and Partitioning dans GNU Guile Reference Manual). Par exemple, l’expression suivante renvoie une liste qui contient tous les services dans %desktop-services sauf le service Avahi :

(remove (lambda (service)
          (eq? (service-kind service) avahi-service-type))
        %desktop-services)

Instancier le système

En supposant que la déclaration operating-system est stockée dans le fichier my-system-config.scm, la commande guix system reconfigure my-system-config.scm instancie cette configuration et en fait l’entrée par défaut dans GRUB (voir Invoquer guix system).

Pour changer la configuration du système, on met normalement à jour ce fichier et on relance guix system reconfigure. On ne devrait jamais avoir à modifier de fichiers dans /etc ou à lancer des commandes qui modifient l’état du système comme useradd ou grub-install. En fait, vous devez les éviter parce que non seulement ça annulerait vos garanties, mais ça empêcherait aussi de revenir à des versions précédents du système, si vous en avez besoin.

En parlant de revenir en arrière, à chaque fois que vous lancez guix system reconfigure, une nouvelle génération du système est crée — sans modifier ou supprimer les générations précédentes. Les anciennes générations du système ont une entrée dans le menu du chargeur d’amorçage, ce qui vous permet de démarrer dessus au cas où quelque chose se serait mal passé avec la dernière génération. C’est rassurant, non ? La commande guix system list-generations liste les générations du système disponibles sur le disque. Il est possible de revenir à une ancienne génération via les commandes guix system roll-back et guix system switch-generation.

Bien que la commande guix system reconfigure ne modifiera pas les générations précédentes, vous devez faire attention lorsque votre génération actuelle n’est pas la dernière (p. ex. après avoir invoqué guix system roll-back), puisque l’opération pourrait remplacer une génération suivante (voir Invoquer guix system).

L’interface de programmation

Au niveau Scheme, la grosse déclaration operating-system est instanciée avec la procédure monadique suivante (voir La monade du dépôt) :

Procédure monadique : operating-system-derivation os

Renvoie une dérivation qui construit os, un objet operating-system (voir Dérivations).

La sortie de la dérivation est un répertoire qui se réfère à tous les paquets et d’autres fichiers supports requis pour instancier os.

Cette procédure est fournie par le module (gnu system). Avec (gnu services) (voir Services), ce module contient les entrailles du système Guix. Ouvrez-le un jour !


Suivant: , Précédent: , Monter: Configuration système   [Table des matières][Index]

10.2 Référence de operating-system

Cette section résume toutes les options disponibles dans les déclarations operating-system (voir Utiliser le système de configuration).

Type de données : operating-system

C’est le type de données représentant une configuration d’un système d’exploitation. On veut dire par là toute la configuration globale du système, mais pas la configuration par utilisateur (voir Utiliser le système de configuration).

kernel (par défaut : linux-libre)

L’objet du paquet du système d’exploitation à utiliser25.

hurd (par défaut : #f)

L’objet du paquet du hurd à être lancé par le noyau. Lorsque ce champ est défini, produire un système d’exploitation GNU/Hurd. Dans ce cas, kernel doit également être défini sur le paquet gnumach — le micro-noyau sur lequel tourne le Hurd.

Attention : Cette fonction est expérimentale et seulement prise en charge pour les images de disques.

kernel-loadable-modules (par défault: ’())

Une liste d’objets (généralement des paquets) pour collecter les modules de noyau chargeables depuis - par exemple (liste ddcci-driver-linux).

server-arguments (par défaut : %default-kernel-arguments)

Liste de chaînes ou de gexps représentant des arguments supplémentaires à passer sur la ligne de commande du noyau — p. ex. ("console=ttyS0").

bootloader

L’objet de configuration du chargeur d’amorçage. Voir Configuration du chargeur d'amorçage.

label

C’est l’étiquette (une chaîne de caractères) comme elle apparaît dans l’entrée du menu du chargeur d’amorçage. L’étiquette par défaut inclus le nom du noyau et sa version.

keyboard-layout (par défaut : #f)

This field specifies the keyboard layout to use in the console. It can be either #f, in which case the default keyboard layout is used (usually US English), or a <keyboard-layout> record. Voir Disposition du clavier, for more information.

Cette disposition du clavier est effective dès que le noyau démarre. Par exemple, c’est la disposition du clavier effective lorsque vous saisissez la phrase de passe de votre système de fichier racine sur une partition utilisant luks-device-mapping (voir Périphériques mappés).

Remarque : Cela ne spécifie pas la disposition clavier utilisée par le chargeur d’amorçage, ni celle utilisée par le serveur d’affichage graphique. Voir Configuration du chargeur d'amorçage, pour plus d’information sur la manière de spécifier la disposition du clavier pour le chargeur d’amorçage. Voir Système de fenêtrage X, pour plus d’informations sur la manière de spécifier la disposition du clavier utilisée par le système de fenêtrage X.

initrd-modules (par défaut : %base-initrd-modules)

La liste des modules du noyau linux requis dans l’image disque de RAM initiale. Voir Disque de RAM initial.

initrd (par défaut : base-initrd)

Une procédure qui renvoie un disque de RAM initial pour le noyau Linux. Ce champ est fournit pour pouvoir personnaliser son système à bas-niveau et n’est que rarement utile dans le cas général. Voir Disque de RAM initial.

firmware (par défaut : %base-firmware)

Liste les paquets de microgiciels chargeables pour le noyau de système d’exploitation.

La valeur par défaut contient les microgiciels requis pour les périphériques WiFi Atheros et Broadcom (modules ath9k et b43-open de Linux-libre, respectivement). Voir Considérations matérielles, pour plus d’info sur les périphériques supportés.

host-name

Le nom d’hôte.

hosts-file

Un objet simili-fichier (voir file-like objects) à utiliser comme /etc/hosts (voir Host Names dans The GNU C Library Reference Manual). La valeur par défaut est un fichier avec des entrées pour localhost et host-name.

mapped-devices (par défaut : '())

Une liste de périphériques mappés. Voir Périphériques mappés.

file-systems

Une liste de systèmes de fichiers. Voir Systèmes de fichiers.

swap-devices (par défaut : '())

Une liste d’UUID, d’étiquettes de systèmes de fichiers, ou de chaines identifiant des périphériques ou des fichiers à utiliser comme « espace d’échange » (voir Memory Concepts dans The GNU C Library Reference Manual). Voici quelques exemples :

(list (uuid "4dab5feb-d176-45de-b287-9b0a6e4c01cb"))

Use the swap partition with the given UUID. You can learn the UUID of a Linux swap partition by running swaplabel device, where device is the /dev file name of that partition.

(list (file-system-label "swap"))

Utilise la partition avec l’étiquette swap. De nouveau, la commande swaplabel vous permet de voir et de changer l’étiquette d’une partition swap de Linux.

(list "/swapfile")

utilise le fichier /swapfile comme espace d’échange.

(list "/dev/sda3" "/dev/sdb2")

Utilise les partitions /dev/sda3 et /dev/sdb2 comme espaces d’échange. Nous recommandons plutôt de vous référer aux périphériques d’échange par leur UUID ou étiquette comme montré plus haut.

Il est possible de spécifier un fichier d’échange sur un périphérique mappé (sous /dev/mapper), tant que le périphérique nécessaire et le système de fichiers sont aussi spécifiés. Voir Périphériques mappés et Systèmes de fichiers.

users (par défaut : %base-user-accounts)
groups (par défaut : %base-groups)

Liste les comptes utilisateurs et les groupes. Voir Comptes utilisateurs.

Si la liste users n’a pas de compte lié à l’UID 0, un compte « root » avec l’UID 0 est automatiquement ajouté.

skeletons (par défaut : (default-skeletons))

Une liste de « couples » de noms de fichiers cibles/objets de type fichier (voir objets de type fichier). Ce sont les fichiers squelettes qui seront ajoutés au répertoire d’accueil des comptes utilisatrice·eur·s nouvellement créés.

Par exemple, un valeur valide ressemblerait à cela :

`((".bashrc" ,(plain-file "bashrc" "echo Hello\n"))
  (".guile" ,(plain-file "guile"
                         "(use-modules (ice-9 readline))
                          (activate-readline)")))
issue (par défaut : %default-issue)

Une chaîne qui dénote le contenu du fichier /etc/issue qui est affiché lorsqu’un utilisateur se connecte sur la console.

packages (par défaut : %base-packages)

Une liste de paquets à installer dans le profil global, qui est accessible à partir de /run/current-system/profile. Chaque élément est soit une variable de paquet, soit un tuple de paquet/sortie. Voici un exemple simple des deux :

(cons* git                     ; la sortie "out" par défaut
       (list git "send-email") ; une autre sortie de git
       %base-packages)         ; l'ensemble par défaut

L’ensemble par défaut contient les utilitaires de base et c’est une bonne pratique d’installer les utilitaires non essentiels dans les profils utilisateurs (voir Invoquer guix package).

timezone

Une chaîne identifiant un fuseau horaire — p. ex. "Europe/Paris".

Vous pouvez lancer la commande tzselect pour trouver le fuseau horaire correspondant à votre région. Si vous choisissez un nom de fuseau horaire invalide, guix system échouera.

locale (par défaut : "en_US.utf8")

Le nom du paramètre régional par défaut (voir Locale Names dans The GNU C Library Reference Manual). Voir Régionalisation, pour plus d’informations.

locale-definitions (par défaut : %default-locale-definitions)

La liste des définitions de locales à compiler et qui devraient être utilisées à l’exécution. Voir Régionalisation.

locale-libcs (par défaut : (list glibc))

La liste des paquets GNU libc dont les données des paramètres linguistiques sont utilisées pour construire les définitions des paramètres linguistiques. Voir Régionalisation, pour des considérations sur la compatibilité qui justifient cette option.

name-service-switch (par défaut : %default-nss)

La configuration de NSS de la libc (name service switch) — un objet <name-service-switch>. Voir Name Service Switch, pour des détails.

services (par défaut : %base-services)

Une liste d’objets services qui dénotent les services du système. Voir Services.

essential-services (par défaut : …)

La liste des « services essentiels » — c.-à-d. les services comme des instance de system-service-type et host-name-service-type (voir Référence de service), qui sont dérivés de la définition du système d’exploitation lui-même. En tant qu’utilisateur vous ne devriez jamais toucher à ce champ.

pam-services (par défaut : (base-pam-services))

Services PAM (pluggable authentication module) Linux.

setuid-programs (par défaut : %setuid-programs)

Liste de G-expressions qui s’évaluent en chaînes de caractères qui dénotent les programmes setuid. Voir Programmes setuid.

sudoers-file (par défaut : %sudoers-specification)

Le contenu du fichier /etc/sudoers comme un objet simili-fichier (voir local-file et plain-file).

Ce fichier spécifier quels utilisateurs peuvent utiliser la commande sudo, ce qu’ils ont le droit de faire, et quels privilèges ils peuvent gagner. La valeur par défaut est que seul root et les membres du groupe wheel peuvent utiliser sudo.

Type de données : this-operating-system

Lorsqu’il est utilisée dans la portée lexicale de la définition d’un du système d’exploitation, cet identifiant est résolu comme étant le système d’exploitation définit.

L’exemple ci-dessous montre le référencement au système d’exploitation définit dans la définition du champ label :

(use-modules (gnu) (guix))

(operating-system
  ;; ...
  (label (package-full-name
          (operating-system-kernel this-operating-system))))

C’est une erreur que de se référer à this-operating-system en dehors de la définition d’un système d’exploitation.


Suivant: , Précédent: , Monter: Configuration système   [Table des matières][Index]

10.3 Systèmes de fichiers

La liste des systèmes de fichiers à monter est spécifiée dans le champ file-systems de la déclaration de système d’exploitation (voir Utiliser le système de configuration). Chaque système de fichier est déclaré avec la forme file-system, comme ceci :

(file-system
  (mount-point "/home")
  (device "/dev/sda3")
  (type "ext4"))

Comme d’habitude, certains de ces champs sont obligatoire — comme le montre l’exemple au-dessus — alors que d’autres peuvent être omis. Ils sont décrits plus bas.

Type de données : file-system

Les objets de ce type représentent des systèmes de fichiers à monter. Ils contiennent les membres suivants :

type

C’est une chaîne de caractères spécifiant le type du système de fichier — p. ex. "ext4".

mount-point

Désigne l’emplacement où le système de fichier sera monté.

device

Ce champ nomme le système de fichier « source ». il peut être l’une de ces trois choses : une étiquette de système de fichiers, un UUID de système de fichier ou le nom d’un nœud dans /dev. Les étiquettes et les UUID offrent une manière de se référer à des systèmes de fichiers sans avoir à coder en dur le nom de périphérique26.

Les étiquettes de systèmes de fichiers sont crées avec la procédure file-system-label, les UUID avec uuid et les nœuds de /dev sont de simples chaînes de caractères. Voici un exemple d’un système de fichiers référencé par son étiquette, donnée par la commande e2label :

(file-system
  (mount-point "/home")
  (type "ext4")
  (device (file-system-label "my-home")))

Les UUID sont convertis à partir de leur représentation en chaîne de caractères (montrée par la command tune2fs -l) en utilisant la forme uuid27, comme ceci :

(file-system
  (mount-point "/home")
  (type "ext4")
  (device (uuid "4dab5feb-d176-45de-b287-9b0a6e4c01cb")))

Lorsque la source d’un système de fichiers est un périphérique mappé (voir Périphériques mappés), sont champ device doit se référer au nom du périphérique mappé — p. ex. "/dev/mapper/root-partition". Cela est requis pour que le système sache que monter ce système de fichier dépend de la présence du périphérique mappé correspondant.

flags (par défaut : '())

C’est une liste de symboles qui désignent des drapeaux de montage. Les drapeaux reconnus sont read-only, bind-mount, no-dev (interdit l’accès aux fichiers spéciaux), no-suid (ignore les bits setuid et setgid), no-atime (ne met pas à jour les heures d’accès aux fichiers) et no-exec (interdit l’exécution de programmes). Voir Mount-Unmount-Remount dans The GNU C Library Reference Manual, pour plus d’informations sur ces drapeaux.

options (par défaut : #f)

Il s’agit soit de #f, soit d’une chaîne indiquant les options de montage passées au pilote du système de fichiers. Voir Mount-Unmount-Remount dans The GNU C Library Reference Manual, pour plus de détails et lancez man 8 mount pour les options des différents systèmes de fichiers. Notez que les procédures file-system-options->alist et alist->file-system-options de (gnu system file-systems) peuvent être utilisées pour convertir des options de systèmes de fichiers données sous forme de liste d’association en représentation de chaîne de caractères, et vice-versa.

mount? (par défaut : #t)

Cette valeur indique s’il faut monter automatiquement le système de fichier au démarrage du système. Lorsque la valeur est #f, le système de fichier reçoit une entrée dans /etc/fstab (lue par la commande mount) mais n’est pas monté automatiquement.

needed-for-boot? (par défaut : #f)

Cette valeur booléenne indique si le système de fichier est nécessaire au démarrage. Si c’est vrai alors le système de fichier est monté au chargement du disque de RAM initial. C’est toujours le cas par exemple du système de fichiers racine.

check? (par défaut : #t)

Cette valeur booléenne indique si le système de fichier doit être vérifié avant de le monter.

create-mount-point? (par défaut : #f)

Lorsque cette valeur est vraie, le point de montage est créé s’il n’existe pas déjà.

mount-may-fail? (par défaut : #t)

Lorsque cela est vrai, indique que le montage de ce système de fichiers peut échouer, mais cela ne doit pas être considéré comme une erreur. Ceci est utile dans des cas inhabituels ; un exemple de ceci est efivarfs, un système de fichiers qui ne peut être monté que sur des systèmes EFI/UEFI.

dependencies (par défaut : '())

C’est une liste d’objets <file-system> ou <mapped-device> qui représentent les systèmes de fichiers qui doivent être montés ou les périphériques mappés qui doivent être ouverts avant (et monté ou fermés après) celui-ci.

Par exemple, considérons une hiérarchie de montage : /sys/fs/cgroup est une dépendance de /sys/fs/cgroup/cpu et /sys/fs/cgroup/memory.

Un autre exemple est un système de fichier qui dépend d’un périphérique mappé, par exemple pour une partition chiffrée (voir Périphériques mappés).

Procédure Scheme : file-system-label str

Cette procédure renvoie un label de système de fichiers opaque à partir de str, une chaîne de caractères :

(file-system-label "home")
 #<file-system-label "home">

Les étiquettes de systèmes de fichiers sont utilisées pour faire référence aux systèmes de fichiers par étiquette plutôt que par nom de dispositif. Voir ci-dessus pour des exemples.

Le module (gnu system file-systems) exporte les variables utiles suivantes.

Variable Scheme : %base-file-systems

Ce sont les systèmes de fichiers essentiels qui sont requis sur les systèmes normaux, comme %pseudo-terminal-file-system et %immutable-store (voir plus bas). Les déclarations de systèmes d’exploitation devraient au moins les contenir.

Variable Scheme : %pseudo-terminal-file-system

C’est le système de fichier monté sur /dev/pts. Il supporte les pseudo-terminaux créés via openpty et les fonctions similaires (voir Pseudo-Terminals dans The GNU C Library Reference Manual). Les pseudo-terminaux sont utilisés par les émulateurs de terminaux comme xterm.

Variable Scheme : %shared-memory-file-system

Ce système de fichier est monté dans /dev/shm et est utilisé pour le partage de mémoire entre processus (voir shm_open dans The GNU C Library Reference Manual).

Variable Scheme : %immutable-store

Ce système de fichiers effectue un « montage lié » en lecture-seule de /gnu/store, ce qui en fait un répertoire en lecture-seule pour tous les utilisateurs dont root. Cela évite que des logiciels qui tournent en root ou des administrateurs systèmes ne modifient accidentellement le dépôt.

Le démon lui-même est toujours capable d’écrire dans le dépôt : il est remonté en lecture-écriture dans son propre « espace de nom ».

Variable Scheme : %binary-format-file-system

Le système de fichiers binfmt_misc, qui permet de gérer n’importe quel type de fichiers exécutables à déléguer en espace utilisateur. Cela demande que le module du noyau binfmt.ko soit chargé.

Variable Scheme : %fuse-control-file-system

Le système de fichiers fusectl, qui permet à des utilisateurs non privilégiés de monter et de démonter des systèmes de fichiers FUSE en espace utilisateur. Cela requiert que le module du noyau fuse.ko soit chargé.

Le module (gnu system uuid) fournit les outils pour traiter les « identifiants uniques » de système de fichier (UUIDs).

Procédure Scheme : uuid type [value]

Renvoie un objet UUID (identifiant unique) opaque du type donné (un symbole) en analysant str (une chaîne) :

(uuid "4dab5feb-d176-45de-b287-9b0a6e4c01cb")
 #<uuid> type: dce bv: …>

(uuid "1234-ABCD" 'fat)
 #<uuid> type: fat bv: …>

type peut être l’un des codes suivants : dce, iso9660, fat, ntfs, ou l’un des synonymes les plus courants.

Les UUIDs sont un autre moyen de faire référence sans ambiguïté aux systèmes de fichiers dans la configuration du système d’exploitation. Voir les exemples ci-dessus.


Monter: Systèmes de fichiers   [Table des matières][Index]

10.3.1 Système de fichier Btrfs

Btrfs a des particularités, comme les sous-volumes, qui méritent d’être expliquées plus en détail. La section suivante tente de couvrir les utilisations de base ainsi que les utilisations complexes d’un système de fichiers Btrfs avec le système Guix.

Dans son usage le plus simple, un système de fichier Btrfs peut être décrit, par exemple, par :

(file-system
  (mount-point "/home")
  (type "btrfs")
  (device (file-system-label "my-home")))

L’exemple ci-dessous est plus complexe, car il utilise un sous-volume de Btrfs, nommé rootfs. Le système de fichiers Btrfs parent est appelé my-btrfs-pool, et se trouve sur un périphérique crypté (d’où la dépendance à l’égard de mapped-devices) :

(file-system
  (device (file-system-label "my-btrfs-pool"))
  (mount-point "/")
  (type "btrfs")
  (options "subvol=rootfs")
  (dependencies mapped-devices))

Certains chargeurs d’amorçage, par exemple GRUB, ne montent une partition Btrfs qu’à son niveau supérieur au début du démarrage, et s’appuient sur leur configuration pour se référer au chemin correct du sous-volume à l’intérieur de ce niveau supérieur. Les chargeurs d’amorçage fonctionnant de cette manière produisent généralement leur configuration sur un système en cours d’exécution où les partitions Btrfs sont déjà montées et où les informations sur les sous-volumes sont facilement disponibles. Par exemple, grub-mkconfig, la commande de générateur de configuration livrée avec GRUB, lit /proc/self/mountinfo pour déterminer le chemin de niveau supérieur d’un sous-volume.

Guix System produit une configuration de bootloader en utilisant la configuration du système d’exploitation comme seule entrée ; il est donc nécessaire d’extraire le nom du sous-volume sur lequel vit /gnu/store (s’il existe) de cette configuration du système d’exploitation. Pour mieux illustrer cela, considérons un sous-volume nommé "rootfs" qui contient les données du système de fichiers racine. Dans une telle situation, le chargeur de démarrage GRUB ne verrait que le niveau supérieur de la partition Btrfs de la racine, par exemple :

/                   (niveau supérieur)
├── rootfs          (répertoire des sous-volumes)
    ├── gnu         (répertoire normal)
        ├── store   (répertoire normal)
[...]

Ainsi, le nom du sous-volume doit être précédé du chemin /gnu/store du noyau, des binaires initrd et de tout autre fichier mentionné dans la configuration GRUB qui doit être trouvé au début du démarrage.

L’exemple suivant montre une hiérarchie imbriquée de sous-volumes et de répertoires :

/                   (niveau supérieur)
├── rootfs          (sous-volume)
    ├── gnu         (répertoire normal)
        ├── store   (sous-volume)
[...]

Ce scénario fonctionnerait sans monter le sous-volume « store ». Le montage de "rootfs" est suffisant, puisque le nom du sous-volume correspond à son point de montage prévu dans la hiérarchie du système de fichiers. Une autre solution consiste à faire référence au sous-volume « store » en définissant l’option subvol soit /rootfs/gnu/store soit rootfs/gnu/store.

Enfin, un exemple plus élaboré de sous-volumes imbriqués :

/                           (niveau supérieur)
├── root-snapshots          (sous-volume)
    ├── root-current        (sous-volume)
        ├── guix-store      (sous-volume)
[...]

Ici, le sous-volume « guix-store » ne correspond pas à son point de montage prévu, il est donc nécessaire de le monter. Le sous-volume doit être entièrement spécifié, en passant son nom de fichier à l’option subvol. Par exemple, le sous-volume « guix-store » peut être monté sur /gnu/store en utilisant une déclaration de système de fichiers telle que :

(file-system
  (device (file-system-label "btrfs-pool-1"))
  (mount-point "/gnu/store")
  (type "btrfs")
  (options "subvol=root-snapshots/root-current/guix-store,\
compress-force=zstd,space_cache=v2"))

Suivant: , Précédent: , Monter: Configuration système   [Table des matières][Index]

10.4 Périphériques mappés

The Linux kernel has a notion of device mapping: a block device, such as a hard disk partition, can be mapped into another device, usually in /dev/mapper/, with additional processing over the data that flows through it28. A typical example is encryption device mapping: all writes to the mapped device are encrypted, and all reads are deciphered, transparently. Guix extends this notion by considering any device or set of devices that are transformed in some way to create a new device; for instance, RAID devices are obtained by assembling several other devices, such as hard disks or partitions, into a new one that behaves as one partition.

Les périphériques mappés sont déclarés avec la forme mapped-device, définie comme suit ; par exemple, voir ci-dessous.

Type de données : mapped-device

Les objets de ce type représentent des mappages de périphériques qui seront effectués au démarrage du système.

source

This is either a string specifying the name of the block device to be mapped, such as "/dev/sda3", or a list of such strings when several devices need to be assembled for creating a new one. In case of LVM this is a string specifying name of the volume group to be mapped.

target

This string specifies the name of the resulting mapped device. For kernel mappers such as encrypted devices of type luks-device-mapping, specifying "my-partition" leads to the creation of the "/dev/mapper/my-partition" device. For RAID devices of type raid-device-mapping, the full device name such as "/dev/md0" needs to be given. LVM logical volumes of type lvm-device-mapping need to be specified as "VGNAME-LVNAME".

targets

This list of strings specifies names of the resulting mapped devices in case there are several. The format is identical to target.

type

Ce doit être un objets mapped-device-kind, qui spécifie comment source est mappés sur target.

Variable Scheme : luks-device-mapping

Cela définie les périphériques blocs chiffrés en LUKS avec cryptsetup du paquet du même nom. Elle s’appuie sur le module du noyau Linux dm-crypt.

Variable Scheme : raid-device-mapping

Cela définie un périphérique RAID qui est assemblé avec la commande mdadm du paquet du même nom. Elle nécessite un module noyau Linux approprié pour le niveau RAID chargé, comme raid456 pour RAID-4, RAID-5 et RAID-6 ou raid10 pour RAID-10.

Scheme Variable : lvm-device-mapping

This defines one or more logical volumes for the Linux Logical Volume Manager (LVM). The volume group is activated by the vgchange command from the lvm2 package.

L’exemple suivant spécifie un mappage de /dev/sda3 vers /dev/mapper/home avec LUKS — Linux Unified Key Setup, un mécanisme standard pour chiffrer les disques. Le périphérique /dev/mapper/home peut ensuite être utilisé comme device d’une déclaration file-system (voir Systèmes de fichiers).

(mapped-device
  (source "/dev/sda3")
  (target "home")
  (type luks-device-mapping))

Autrement, pour devenir indépendant du numéro de périphérique, on peut obtenir l’UUID LUKS (l’identifiant unique) du périphérique source avec une commande comme :

cryptsetup luksUUID /dev/sda3

et l’utiliser ainsi :

(mapped-device
  (source (uuid "cb67fc72-0d54-4c88-9d4b-b225f30b0f44"))
  (target "home")
  (type luks-device-mapping))

Il est aussi désirable de chiffrer l’espace d’échange, puisque l’espace d’échange peut contenir des données sensibles. Une manière de faire cela est d’utiliser un fichier d’échange dans un système de fichiers sur un périphérique mappé avec un chiffrement LUKS. De cette manière, le fichier d’échange est chiffré parce que tout le périphérique est chiffré. Voir Disk Partitioning, pour un exemple.

Un périphérique RAID formé des partitions /dev/sda1 et /dev/sdb1 peut être déclaré ainsi :

(mapped-device
  (source (list "/dev/sda1" "/dev/sdb1"))
  (target "/dev/md0")
  (type raid-device-mapping))

Le périphérique /dev/md0 peut ensuite être utilisé comme device d’une déclaration file-system (voir Systèmes de fichiers). Remarquez que le niveau de RAID n’a pas besoin d’être donné ; il est choisi pendant la création initiale du périphérique RAID et est ensuite déterminé automatiquement.

LVM logical volumes “alpha” and “beta” from volume group “vg0” can be declared as follows:

(mapped-device
  (source "vg0")
  (targets (list "vg0-alpha" "vg0-beta"))
  (type lvm-device-mapping))

Devices /dev/mapper/vg0-alpha and /dev/mapper/vg0-beta can then be used as the device of a file-system declaration (voir Systèmes de fichiers).


Suivant: , Précédent: , Monter: Configuration système   [Table des matières][Index]

10.5 Comptes utilisateurs

Les comptes utilisateurs et les groupes sont gérés entièrement par la déclaration operating-system. Ils sont spécifiés avec les formes user-account et user-group :

(user-account
  (name "alice")
  (group "users")
  (supplementary-groups '("wheel"   ;permet d'utiliser sudo, etc.
                          "audio"   ;carte son
                          "video"   ;périphériques réseaux comme les webcams
                          "cdrom")) ;le bon vieux CD-ROM
  (comment "Bob's sister"))

Voici un compte d’utilisateur·rice qui utilise un shell différent et un répertoire d’accueil personnalisé (le répertoire par défaut serait "/home/bob") :

(user-account
  (name "bob")
  (group "users")
  (comment "Alice's bro")
  (shell (file-append zsh "/bin/zsh"))
  (home-directory "/home/robert"))

Lors du démarrage ou à la fin de guix system reconfigure, le système s’assure que seuls les comptes utilisateurs et les groupes spécifiés dans la déclaration operating-system existent, et avec les propriétés spécifiées. Ainsi, les modifications ou les créations de comptes ou de groupes effectuées directement en invoquant des commandes comme useradd sont perdue à la reconfiguration ou au redémarrage. Cela permet de s’assurer que le système reste exactement tel que déclaré.

Type de données : user-account

Les objets de se type représentent les comptes utilisateurs. Les membres suivants peuvent être spécifiés :

name

Le nom du compte utilisateur.

group

C’est le nom (une chaîne) ou un identifiant (un nombre) du groupe utilisateur auquel ce compte appartient.

supplementary-groups (par défaut : '())

Éventuellement, cela peut être définie comme une liste de noms de groupes auxquels ce compte appartient.

uid (par défaut : #f)

C’est l’ID utilisateur de ce compte (un nombre) ou #f. Dans ce dernier cas, le nombre est choisi automatiquement par le système à la création du compte.

comment (par défaut : "")

Un commentaire à propos du compte, comme le nom complet de l’utilisateur.

home-directory

C’est le nom du répertoire personnel du compte.

create-home-directory? (par défaut : #t)

Indique si le répertoire personnel du compte devrait être créé s’il n’existe pas déjà.

shell (par défaut : Bash)

C’est une G-expression qui désigne le nom de fichier d’un programme utilisé comme shell (voir G-Expressions). Par exemple, vous pourriez vous référer à l’exécutable Bash comme ceci :

(file-append bash "/bin/bash")

... et à l’ exécutable Zsh comme ceci :

(file-append zsh "/bin/zsh")
system? (par défaut : #f)

C’est une valeur booléenne qui indique si le compte est un compte « système ». Les comptes systèmes sont parfois traités à part ; par exemple, les gestionnaires de connexion graphiques ne les liste pas.

password (par défaut : #f)

Vous laisseriez normalement ce champ à #f et initialiseriez les mots de passe utilisateurs en tant que root avec la commande passwd, puis laisseriez l’utilisateur le changer avec passwd. Les mots de passes définis avec passwd sont bien sûr préservés après redémarrage et reconfiguration.

Si vous voulez vraiment définir un mot de passe pour un compte, alors ce champ doit contenir le mot de passe chiffré, comme une chaîne de caractère. Vous pouvez utiliser la procédure crypt pour cela :

(