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.0.1, 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 the Translation Project.


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 fournit une interface de gestion des paquets par la ligne de commande (voir Gestion de paquets), des outils pour aider au développement logiciel (voir Développement), des utilitaires en ligne de commande pour des utilisations plus avancées (voir Utilitaires) ainsi que des interfaces de programmation Scheme (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

l’architecture Intel et AMD x86_64 avec le noyau Linux-libre ;

i686-linux

l’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

little-endian 64-bit ARMv8-A processors, Linux-Libre kernel.

mips64el-linux

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, the project’s build farms no longer provide substitutes for this architecture.

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 vous recommandons d’utiliser ce script d’installation shell. Ce script automatise le téléchargement, l’installation et les étapes de configuration initiales décrites plus bas. Vous devriez le lancer en tant que root.

L’installation se comme ceci :

  1. Téléchargez l’archive binaire depuis ‘https://ftp.gnu.org/gnu/guix/guix-binary-1.0.1.système.tar.xz’, où système est x86_64-linux pour une machine x86_64 sur laquelle tourne déjà le noyau Linux, etc.

    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.0.1.système.tar.xz.sig
    $ gpg --verify guix-binary-1.0.1.système.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.

    Take note that a warning like “This key is not certified with a trusted signature!” is 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 \
         /path/to/guix-binary-1.0.1.system.tar.xz
    # mv var/guix /var/ && mv gnu /
    

    Cela crée /gnu/store (voir Le dépôt) and /var/guix. Ce deuxième dossier 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 s’assure que GNU tar ne produise pas d’avertissement disant que « l’horodatage est trop vieux pour être plausible » (ces avertissements étaient produits par GNU tar 1.26 et précédents ; les versions récentes n’ont pas ce problème). Cela vient du fait que les fichiers de l’archive ont pour date de modification zéro (ce qui signifie le 1er janvier 1970). C’est fait exprès pour s’assurer que le contenu de l’archive ne dépende pas de la date de création, ce qui la rend 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
    

    Sourcez 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/guix-daemon.service \
         /etc/systemd/system/
    # systemctl start guix-daemon && systemctl enable 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
    

    Comme cela, en supposant que /usr/local/share/info est dans le chemin de recherche, lancer info guix ouvrira ce manuel (voir Other Info Directories dans GNU Texinfo, pour plus de détails sur comment changer le chemin de recherche de 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 :

À moins que --disable-daemon ne soit passé à configure, les paquets suivants sont aussi requis :

When configuring Guix on a system that already has a Guix installation, be sure to specify the same state directory as the existing installation using the --localstatedir option of the configure script (voir localstatedir dans GNU Coding Standards). Usually, this localstatedir option is set to the value /var. The configure script protects against unintended misconfiguration of localstatedir so you do not inadvertently corrupt your store (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"

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 tient aussi compte de la variable d’environnement http_proxy pour ses téléchargements HTTP, 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 de lancer guix-daemon si vous passez --disable-chroot. Cependant, les processus de construction ne seront pas isolés les uns des autres ni du reste du système. Ainsi les processus de construction peuvent interférer les uns avec les autres, et peuvent accéder à des programmes, des bibliothèques et d’autres fichiers présents sur le système — ce qui rend plus difficile de les voir 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érivations 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. 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 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.))     ;très rapide !

      (build-machine
        (name "meeps.example.org")
        (system "mips64el-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 une pour l’architecture mips64el.

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.

system

Le type de système de la machine distante, p. ex. "x86_64-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.

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

Cela essaiera de se connecter à toutes les machines de construction spécifiées dans /etc/guix/machines.scm, s’assurera que Guile et les modules Guix sont disponibles sur toutes les machines et tentera d’exporter vers la machine et d’importer depuis elle, et rapportera toute erreur survenu pendant le processus.

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.

    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 UID 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, elle a un espace de montage séparé, son propre espace de PID, son espace 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 sous /tmp ou sous le répertoire spécifié par sa variable d’environnement TMPDIR. Ce répertoire est partagé avec le conteneur pendant la durée de la construction, bien que dans le conteneur, l’arborescence de construction est toujours appelée /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 actif. 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 tourne 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).

--no-offload

Do not use offload builds to other machines (voir Réglages du délestage du démon). That is, always build things locally instead of offloading builds to remote machines.

--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 modifié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 modifié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 modifié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 modifié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.

--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’elle est à « yes », le GC gardera les sorties de toutes les dérivations — les fichiers .drv — accessibles dans le dépôt. La valeur par défaut est « no », ce qui signifie que les sorties des dérivations ne sont gardées que si elles sont accessibles à partir d’une racine du GC. Voir Invoquer guix gc pour plus d’informations sur les racines du GC.

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

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

Lorsqu’elle est à « 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, avec --gc-keep-derivations à « yes », l’accessibilité des sorties s’étend des sorties aux dérivations et avec --gc-keep-outputs à « yes », elle s’étend des dérivations aux sorties. Quand les deux options sont à « yes », le GC gardera tous les prérequis de construction (les sources, le compilateur, les bibliothèques, et les autres outils de construction) des objets accessibles dans le dépôt, indépendamment du fait qu’ils soient ou non accessibles depuis une racine du GC. Cela est pratique pour les développeurs car ça leur fait gagner du temps de reconstruction et de téléchargement.

--impersonate-linux-2.6

Sur les système basés sur Linux, se faire passer pour Linux 2.6. Cela signifie que l’appel système du noyau uname rapportera 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 toutes les extrémités spécifiées. 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 police 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.

Once you have installed or removed fonts, or when you notice an application that does not find fonts, you may need to install Fontconfig and to force an update of its font cache by running:

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

When you install Emacs packages with Guix, the Elisp files are placed under the share/emacs/site-lisp/ directory of the profile in which they are installed. The Elisp libraries are made available to Emacs through the EMACSLOADPATH environment variable, which is set when installing Emacs itself.

Additionally, autoload definitions are automatically evaluated at the initialization of Emacs, by the Guix-specific guix-emacs-autoload-packages procedure. If, for some reason, you want to avoid auto-loading the Emacs packages installed with Guix, you can do so by running Emacs with the --no-site-file option (voir Init File dans The GNU Emacs Manual).

2.6.6 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, vous avez en fait besoin du paquet gcc-toolchain. Ce paquet fournit une chaîne d’outils 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 une enveloppe 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 le véritable éditeur de liens avec ce nouvel ensemble d’arguments. Vous pouvez dire à l’enveloppe 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.


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

2.7 Upgrading Guix

To upgrade Guix, run:

guix pull

Voir Invoquer guix pull, for more information.

On a foreign distro, you can upgrade the build daemon by running:

sudo -i guix pull

followed by (assuming your distro uses the systemd service management tool):

systemctl restart guix-daemon.service

On Guix System, upgrading the daemon is achieved by reconfiguring the system (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.0.1 :

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

Vous pouvez télécharger une image d’installation ISO-9660 depuis ‘https://https://ftp.gnu.org/gnu/guix/guix-system-install-1.0.1.système.iso.xz’ et vous pouvez l’écrire sur une clef USB ou la graver sur un DVD, où système est l’une de ces valeurs :

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.0.1.system.iso.xz.sig
$ gpg --verify guix-system-install-1.0.1.system.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.

Take note that a warning like “This key is not certified with a trusted signature!” is 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.0.1.système.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.0.1.système.iso of=/dev/sdX
    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.0.1.système.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.0.1.système.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). Autrement, si vous êtes déjà familier avec GNU/Linux et que vous voulez plus de contrôle que ce que l’installateur graphique ne fournit, 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 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

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 racine, vous pouvez utiliser les utilitaires Cryptsetup et LUKS pour cela (voir man cryptsetup pour plus d’informations). En supposant que vous voulez stocker la partition racine 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 ….

The difference matters here, because guix pull updates the guix command and package definitions only for the user it is ran as. This means that if you choose to use guix system reconfigure in root’s login shell, you’ll need to guix pull separately.

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.0.1.system.iso
    

    -enable-kvm is optional, but significantly improves performance, 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.

Once installation is complete, you can boot the system that’s on your guix-system.img image. Voir Lancer Guix dans une VM, for how to do that.


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 disk-image --file-system-type=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 disk-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 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]

4.1 Fonctionnalités

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]

4.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 compte, 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 "$HOME/.guix-profile/etc/profile"

Dans un environnement multi-utilisateur·rice, les profils sont stockés comme une racine du ramasse-miettes, vers laquelle pointe $HOME/.guix-profile (voir Invoquer guix gc). Ce répertoire est normalement localstatedir/guix/profiles/per-user/compte, où localstatedir est la valeur passée à configure avec --localstatedir et compte le nom du compte. Le répertoire per-user est créé lorsque guix-daemon est démarré 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, comme guile ou un nom de paquet suivi d’un arobase et d’un numéro de version, comme guile@1.8.8 ou simplement guile@1.8 (dans ce dernier cas, la version la plus récente commençant par 1.8 est utilisé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.

D’autre part, les paquets dépendent parfois de la définition de variables d’environnement pour leur chemin de recherche (voir les explications sur --search-paths plus bas). Toute définition de variable d’environnement manquante ou possiblement incorrecte est rapporté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).

--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 une regexp ou plus est spécifiée, la mise à jour n’installera que les paquets dont le nom correspond à regexp. Voyez aussi l’option --do-not-upgrade en 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).

--do-not-upgrade[=regexp …]

Lorsqu’elle est utilisée 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

Create a new generation of the profile from the manifest object returned by the Scheme code in file. This option can be repeated several times, in which case the manifests are concatenated.

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 retourner 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"))
--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, cette option revient en arrière 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 zéroième génération, 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 retournées seront soit les paramètres exactes, ou 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.

profile must be the name of a file that will be created upon completion. Concretely, profile will be a mere symbolic link (“symlink”) pointing to the actual profile where packages are installed:

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

All it takes to get rid of the profile is to remove this symlink and its siblings that point to specific generations:

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

List all the user’s profiles:

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

When running as root, list all the profiles of all the users.

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

You may also specify the full name of a package to only get details about a specific version of it (this time using the guix show alias):

$ 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]

List packages currently available in the distribution for this system (voir Distribution GNU). When regexp is specified, list only available packages whose name matches 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é, supprimer les générations correspondante. Lorsque motif spécifie une durée, les générations plus vieilles 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.

Enfin, comme guix package peut démarrer des processus de construction, elle supporte les options de construction communes (voir Options de construction communes). Elle supporte aussi les options de transformation de paquets comme --with-source (voir Options de transformation de paquets). Cependant, remarquez que les transformations de paquets sont perdues à la mise à jour ; pour les préserver à travers les mises à jours, vous devriez définir vos propres variantes des paquets dans une module Guile et l’ajouter à GUIX_PACKAGE_PATH (voir Définition des paquets).


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

4.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]

4.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]

4.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.

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.0.1.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
…

The text changed from “The following derivations would be built” to “112.3 MB would be downloaded”. This indicates that substitutes from ci.guix.gnu.org are usable and will be downloaded, when possible, for future builds.

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]

4.3.3 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, des machines de constructions produisent souvent les mêmes binaires grâce à des construction reproductibles au bit près (voir plus bas).

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. Cela 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 authentifie la relation entre nom de domaine et clef publique).


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

4.3.4 Paramètres de serveur mandataire

Les substituts sont téléchargés par HTTP ou HTTPS. La variable d’environnement http_proxy peut être initialisée dans l’environnement de guix-daemon et est respectée pour le téléchargement des substituts. Remarquez que la valeur de http_proxy dans l’environnement où tournent guix build, guix package et les autres clients n’a absolument aucun effet.


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

4.3.5 É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]

4.3.6 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]

4.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]

4.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 command guix gc a trois modes d’opération : il peut être utilisé 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

List store items in use by currently running processes. These store items are effectively considered GC roots: they cannot be deleted.

--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 à chaque construction réussie ou import d’archive à moins qu’il n’ait été démarré 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]

4.6 Invoquer guix pull

Les paquets sont installés ou mis à jour vers la dernière version disponible dans la distribution actuellement disponible 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 et 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é.

Specifically, guix pull downloads code from the channels (voir Canaux) specified by one of the followings, in this order:

  1. the --channels option;
  2. the user’s ~/.config/guix/channels.scm file;
  3. the system-wide /etc/guix/channels.scm file;
  4. the built-in default channels specified in the %default-channels variable.

À 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.

Any user can update their Guix copy using guix pull, and the effect is limited to the user who ran guix pull. For instance, when user root runs guix pull, this has no effect on the version of Guix that user alice sees, and 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
switched from generation 3 to 2
$ guix pull --delete-generations=1
deleting /var/guix/profiles/per-user/charlie/current-guix-1-link

You can also use guix package (voir Invoquer guix package) to manage the profile by naming it explicitly:

$ 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

Read the list of channels from file instead of ~/.config/guix/channels.scm or /etc/guix/channels.scm. file must contain Scheme code that evaluates to a list of channel objects. Voir Canaux, for more information.

--news
-N

Display the list of packages added or upgraded since the previous generation, as well as, occasionally, news written by channel authors for their users (voir Writing Channel News).

The package information is the same as displayed upon guix pull completion, but without ellipses; it is also similar to the output of guix pull -l for the last generation (see below).

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

Roll back to the previous generation of ~/.config/guix/current—i.e., undo the last 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é, supprimer les générations correspondante. Lorsque motif spécifie une durée, les générations plus vieilles que la durée spécifiée correspondent. Par exemple --delete-generations=1m supprime les générations vieilles de plus d’un mois.

If the current generation matches, it is not deleted.

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.

--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.

--verbose

Produire une sortie verbeuse, en écrivant les journaux de construction sur la sortie d’erreur standard.

--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]

4.7 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.

4.7.1 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 — sera téléchargé. 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 mon propre 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.

4.7.2 Spécifier des canaux supplémentaires

Vous pouvez aussi spécifier des canaux supplémentaires à récupérer. Disons que vous avez un ensemble de paquets personnels ou de variantes personnalisées 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 utiliser un canal, écrivez dans ~/.config/guix/channels.scm pour dire à guix pull de récupérer votre canal personnel en plus des canaux par défaut de Guix :

;; Ajouter mes paquets personnels à 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
  my-personal-packages dd3df5e
    URL du dépôt : https://example.org/personal-packages.git
    branche : master
    commit : dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb
  11 nouveaux paquets : my-gimp, my-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 my-personal-packages. Parmi les nouveaux paquets et les paquets mis à jour qui sont listés, certains comme my-gimp et my-emacs-with-cool-features peuvent provenir de my-personal-packages, tandis que d’autres viennent du canal par défaut de Guix.

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).

4.7.3 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 une-collection)
   (url "https://exemple.org/premiere-collection.git"))
  (channel
   (name some-autre-collection)
   (url "https://exemple.org/deuxieme-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.

4.7.4 Package Modules in a Sub-directory

As a channel author, you may want to keep your channel modules in a sub-directory. If your modules are in the sub-directory guix, you must add a meta-data file .guix-channel that contains:

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

4.7.5 Writing Channel News

Channel authors may occasionally want to communicate to their users information about important changes in the channel. You’d send them all an email, but that’s not convenient.

Instead, channels can provide a news file; when the channel users run guix pull, that news file is automatically read and guix pull --news can display the announcements that correspond to the new commits that have been pulled, if any.

To do that, channel authors must first declare the name of the news file in their .guix-channel file:

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

The news file itself, etc/news.txt in this example, must look something like this:

(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!"))))

The file consists of a list of news entries. Each entry is associated with a commit or tag: it describes changes made in this commit, possibly in preceding commits as well. Users see entries only the first time they obtain the commit the entry refers to.

The title field should be a one-line summary while body can be arbitrarily long, and both can contain Texinfo markup (voir Overview dans GNU Texinfo). Both the title and body are a list of language tag/message tuples, which allows guix pull to display news in the language that corresponds to the user’s locale.

If you want to translate news using a gettext-based workflow, you can extract translatable strings with xgettext (voir xgettext Invocation dans GNU Gettext Utilities). For example, assuming you write news entries in English first, the command below creates a PO file containing the strings to translate:

xgettext -o news.po -l scheme -ken etc/news.scm

To sum up, yes, you could use your channel as a blog. But beware, this is not quite what your users might expect.

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

;; Deploy specific commits of my channels of interest.
(list (channel
       (name 'guix)
       (url "https://git.savannah.gnu.org/git/guix.git")
       (commit "d894ab8e9bfabcefa6c49d9ba2e834dd5a73a300"))
      (channel
       (name 'my-personal-packages)
       (url "https://example.org/personal-packages.git")
       (commit "dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb")))

The guix describe --format=channels command can even generate this list of channels directly (voir Invoquer guix describe). The resulting file can be used with the -C options of guix pull (voir Invoquer guix pull) or guix time-machine (voir Invoking 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: Gestion de paquets   [Table des matières][Index]

4.8 Invoking guix time-machine

The guix time-machine command provides access to other revisions of Guix, for example to install older versions of packages, or to reproduce a computation in an identical environment. The revision of Guix to be used is defined by a commit or by a channel description file created by guix describe (voir Invoquer guix describe).

La syntaxe générale est :

guix time-machine options… -- command arg

where command and arg… are passed unmodified to the guix command of the specified revision. The options that define this revision are the same as for guix pull (voir Invoquer guix pull):

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

Use the guix channel from the specified url, at the given commit (a valid Git commit ID represented as a hexadecimal string), or branch.

--channels=file
-C file

Read the list of channels from file. file must contain Scheme code that evaluates to a list of channel objects. Voir Canaux for more information.

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

guix time-machine -- build hello

will thus build the package hello as defined in the master branch, which is in general a newer revision of Guix than you have installed. Time travel works in both directions!

Note that guix time-machine can trigger builds of channels and their dependencies, and these are controlled by the standard build options (voir Options de construction communes).


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

4.9 Inférieurs

Remarque : La fonctionnalité décrite ici est un « démonstrateur technique » à la version 1.0.1. 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]

4.10 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")))

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),

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.

--profile=profil
-p profil

Afficher les informations sur le profil.


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

4.11 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

Cependant, remarquez que, dans les deux exemples, le paquet emacs, le profil ainsi que toutes leurs dépendances sont transférés (à cause de -r), indépendamment du fait qu’ils soient ou non disponibles dans le dépôt de la machine cible. L’option --missing peut vous aider à comprendre les éléments qui manquent dans le dépôt de la machine cible. La commande guix copy simplifie et optimise ce processus, c’est donc ce que vous devriez utiliser dans ce cas (voir Invoquer guix copy).

Les archives sont stockées au format « archive normalisé » ou « nar », qui est comparable dans l’esprit à « tar » mais avec des différences qui le rendent utilisable pour ce qu’on veut faire. Tout d’abord, au lieu de stocker toutes les métadonnées Unix de chaque fichier, le format nar ne mentionne que le type de fichier (normal, répertoire ou lien symbolique) ; les permissions Unix, le groupe et l’utilisateur ne sont pas mentionnés. Ensuite, l’ordre dans lequel les entrées de répertoires sont stockés suit toujours l’ordre des noms de fichier dans l’environnement linguistique C. Cela rend la production des archives entièrement déterministe.

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 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 closure des éléments du 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érer une nouvelle paire de clefs pour le démon. Cela est un prérequis avant que les archives ne puissent être exportées avec --export. Remarquez que cette opération prend généralement du temps parce qu’elle doit récupère suffisamment d’entropie pour générer la paire de clefs.

La paire de clefs générée est typiquement stockée dans /etc/guix, dans signing-key.pub (clef publique) et signing-key.sec (clef privée, qui doit rester secrète). Lorsque paramètres est omis, une clef ECDSA utilisant la courbe Ed25519 est générée ou pour les version de libgcrypt avant 1.6.0, une clef 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 clefs 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/…-emacs-24.5 \
  | bunzip2 | 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.

--list
-t

Read a single-item archive as served by substitute servers (voir Substituts) and print the list of files it contains, as in this example:

$ 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]

5 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]

5.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 --pure10.

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 utilisateur, 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 drapeau --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.

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

Create an environment for the packages contained in the manifest object returned by the Scheme code in file. This option can be repeated several times, in which case the manifests are concatenated.

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

Nettoie les variables d’environnement existantes lors de la construction du nouvel environnement, sauf celles spécifiées par --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éfines sont PATH, les variables d’environnement dont le nom commence par SLURM, ainsi que les variables « importante » 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 actuel et /etc/passwd est configuré en conséquence.

Le processus est lancé en tant que l’utilisateur actuel en dehors du conteneur. Dans le conteneur, il a le même UID et GID que l’utilisateur actuel, à moins que vous ne passiez --user (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, lie le profil de l’environnement à ~/.guix-profile dans le conteneur. C’est équivalent à lance la commande ln -s $GUIX_ENVIRONMENT ~/.guix-profile dans le conteneur. La liaison échouera et annulera l’environnement si le répertoire existe déjà, ce qui sera sans doute le cas si guix environment est invoqué dans le répertoire personnel de l’utilisateur.

Certains paquets sont configurés pour chercher des fichiers de configuration et des données dans ~/.guix-profile11 ; --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 seront remontés relativement à /home/UTILISATEUR ; 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

For containers, the default behavior is to share the current working directory with the isolated container and immediately change to that directory within the container. If this is undesirable, --no-cwd will cause the current working directory to not be automatically shared and will change to the user’s home directory within the container instead. See also --user.

--expose=source[=cible]
--share=source[=cible]

For containers, --expose (resp. --share) exposes the file system source from the host system as the read-only (resp. writable) file system target within the container. If target is not specified, source is used as the target mount point in the container.

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).


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

5.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 racine ? Dans ce cas, vous pourriez utiliser l’option --relocatable (voir plus bas). Cette option produit des binaire 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 utilisateurs 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

The result is a tarball that can be passed to the docker load command, followed by docker run:

docker load < file
docker run -ti guile-guile-readline /bin/guile

where file is the image returned by guix pack, and guile-guile-readline is its “image tag”. See the Docker documentation for more information.

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’environnement d’exécution conteneurisé Singularity, 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

This produces a tarball that follows the Docker Image Specification. The “repository name” as it appears in the output of the docker images command is computed from package names passed on the command line or in the manifest file.

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 requires you to provide /bin/sh in the image. For that reason, guix pack -f squashfs always implies -S /bin=bin. Thus, your guix pack invocation must always start with something like:

guix pack -f squashfs bash …

If you forget the bash (or similar) package, singularity run and singularity exec will fail with an unhelpful “no such file or directory” message.

--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 fois12, les binaires repositionnables utilisent PRoot si les espaces de noms ne sont pas utilisables, et ça fonctionne 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 utilisateur, passez --relocatable ou -R deux fois. Dans ce cas, les binaires testeront la prise en charge des espaces de noms utilisateurs et utiliseront PRoot s’ils ne sont pas pris en charge.

Le programme PRoot fournit la prise en charge nécessaire pour la virtualisation du système de fichier. Il y arrive en utilisant l’appel système ptrace sur le programme. 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é.

--entry-point=command

Use command as the entry point of the resulting pack, if the pack format supports it—currently docker and squashfs (Singularity) support it. command must be relative to the profile contained in the pack.

The entry point specifies the command that tools like docker run or singularity run automatically start by default. For example, you can do:

guix pack -f docker --entry-point=bin/guile guile

The resulting pack can easily be loaded and docker run with no extra arguments will spawn 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 même but que l’option de même nom de guix build (voir --expression dans guix build).

--manifest=fichier
-m fichier

Use the packages contained in the manifest object returned by the Scheme code in file. This option can be repeated several times, in which case the manifests are concatenated.

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 "mips64el-linux-gnu" (voir GNU configuration triplets dans Autoconf).

--compression=outil
-C outil

Compresser l’archive résultante avec outil — l’un des outils parmi 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

Make file a symlink to the resulting pack, and register it as a garbage collector root.

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

Print the name of the derivation that builds the pack.

--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: Top   [Table des matières][Index]

6 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 utilisateurs. 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 utilisateurs. La configuration recommandée permet aussi au démon d’effectuer la construction dans des chroots, avec un utilisateur de construction spécifique 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]

6.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 …)13 (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 utilisateurs peuvent stocker des définitions dans des modules avec des noms différents — p. ex. (my-packages emacs)14. Il y a deux manières de rendre ces définitions visibles aux interfaces utilisateurs :

  1. En ajoutant le répertoire contenant vos modules de paquets au chemin de recherche avec le drapeau -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 essentiellement 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]

6.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 essentiellement 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 "mips64el-linux-gnu" (voir Specifying Target Triplets dans Autoconf).

On peut manipuler les paquets de manière arbitraire. Une transformation utile est par exemple la réécriture d’entrées où l’arbre des dépendances d’un paquet est réécrit en replaçant des entrées spécifiques par d’autres :

Procédure Scheme : package-input-rewriting replacements [nom-réécrit] Renvoie une procédure qui, lorsqu'on lui donne un

paquet, remplace des dépendances directes et indirectes (mais pas ses entrées implicites) en fonction de remplacements. remplacements est une liste de paires de paquets ; le premier élément de chaque pair est le paquet à remplacer, le second son remplaçant.

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

Renvoie une procédure qui, étant donné un paquet, applique les remplacements à tous le graphe du paquet (en dehors des entrées implicites). remplacements est une liste de paires de spécifications et de procédures ; chaque spécification est une spécification de paquet comme "gcc" ou "guile@2", et chaque procédure prend un paquet correspondant et renvoie un remplaçant 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?]

Renvoie une procédure qui, avec un paquet, applique proc sur tous les paquets dont il dépend et renvoie le paquet qui en résulte. La procédure arrête la récursion là où cut? renvoie vrai pour un paquet donné.


Suivant: , Monter: Définition des paquets   [Table des matières][Index]

6.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 avec le paquet auquel ils appartiennent (voir guix package, pour des informations sur la manière dont guix package traite les entrées propagées).

Par exemple cela est nécessaire lorsque des bibliothèques C/C++ ont besoin d’en-têtes d’une autre bibliothèque pour être compilé ou lorsqu’un fichier pkg-config se rapporte à un autre via son champ Requires.

Un autre exemple où propagated-inputs est utile est pour les langages auxquels il manque un moyen de retenir le chemin de recherche comme c’est le cas du RUNPATH des fichiers ELF ; cela comprend Guile, Python, Perl et plus. Pour s’assurer que les bibliothèques écrites dans ces langages peuvent trouver le code des bibliothèques dont elles dépendent à l’exécution, les dépendances à l’exécution doivent être listées 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.


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

6.2.2 Référence de origin

Cette section résume toutes les options disponibles dans le déclarations origin (voir Définition des paquets).

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

Un procédure qui gère l’URI.

Quelques exemples :

url-fetch de (guix download)

télécharge un fichier depuis l’URL HTTP, HTTPS ou FTP spécifiée dans le champ uri ;

git-fetch de (guix git-download)

clone le dépôt sous contrôle de version Git et récupère la révision spécifiée dans le champ uri en tant qu’objet git-reference ; un objet git-reference ressemble à cela :

(git-reference
  (url "https://git.savannah.gnu.org/git/hello.git")
  (commit "v2.10"))
sha256

Un bytevector contenant le hash SHA-256 de la source. Typiquement la forme base32 est utilisée ici pour générer le bytevector depuis une chaîne de caractères en base-32.

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.


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

6.3 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).

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).

The main build system is gnu-build-system, which implements the standard build procedure for GNU and many other packages. It is provided by the (guix build-system gnu) module.

Variable Scheme : gnu-build-system

gnu-build-system represents the GNU Build System, and variants thereof (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, notamment15:

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).

The build-side module (guix build gnu-build-system) defines %standard-phases as the default list of build phases. %standard-phases is a list of symbol/procedure pairs, where the procedure implements the actual phase.

La liste des phases utilisées par un paquet particulier peut être modifiée avec le paramètre #:phases. Par exemple, en passant :

#:phases (modify-phases %standard-phases (delete 'configure))

signifie que toutes les procédures décrites plus haut seront utilisées, sauf la phase configure.

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.

Other <build-system> objects are defined to support other conventions and tools used by free software packages. They inherit most of gnu-build-system, and differ mainly in the set of inputs implicitly added to the build process, and in the list of phases executed. Some of these build systems are listed below.

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 ».

Le paramètre #:main-class peut être utilisé avec le fichier de construction minimal pour spécifier la classe principale du jar. Cela rend le fichier jar exécutable. Le paramètre #:test-include peut être utilisé pour spécifier la liste des tests junits à lancer. Il vaut par défaut (list "**/*Test.java"). Le paramètre #:test-exclude peut être utilisé pour désactiver certains tests. Sa valeur par défaut est (list "**/Abstract*.java"), parce que les classes abstraites ne peuvent pas être utilisées comme des 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 construction suppose que les paquets installent leur interface publique (les en-têtes) dans un sous-répertoire de « 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

Ces variables, exportées par (guix build-system asdf), implémentent les procédures de constructions pour les paquets en Common Lisp qui utilisent “ASDF”. ASDF est un dispositif de définition de systèmes pour les programmes et les bibliothèques en Common Lisp.

Le système asdf-build-system/source installe les paquets au format source qui peuvent être chargés avec n’importe quelle implémentation de common lisp, via ASDF. Les autres, comme asdf-build-system/sbcl, installent des binaires au format qu’un implémentation particulière comprend. Ces systèmes de constructions peuvent aussi être utilisés pour produire des programmes exécutables ou des images lisp qui contiennent un ensemble de paquets pré-chargés.

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-.

Pour les paquets binaires, chaque système devrait être défini comme un paquet Guix. Si un paquet origine contient plusieurs systèmes, on peut créer des variantes du paquet pour construire tous les systèmes. Les paquets sources, qui utilisent asdf-build-system/source, peuvent contenir plusieurs systèmes.

Pour créer des programmes exécutables et des images, les procédures côté construction build-program et build-image peuvent être utilisées. Elles devraient être appelées dans une phase de construction après la phase create-symlinks pour que le système qui vient d’être construit puisse être utilisé dans l’image créée. build-program requiert une liste d’expressions Common Lisp dans l’argument #:entry-program.

Si le système n’est pas défini dans son propre fichier .asd du même nom, alors le paramètre #:asd-file devrait être utilisé pour spécifier dans quel fichier le système est défini. De plus, si le paquet défini un système pour ses tests dans un fichier séparé, il sera chargé avant que les tests ne soient lancés s’il est spécifié par le paramètre #:test-asd-file. S’il n’est pas spécifié, les fichiers <system>-tests.asd, <system>-test.asd, tests.asd et test.asd seront testés.

Si pour quelque raison que ce soit le paquet doit être nommé d’une manière différente de ce que la convention de nommage suggère, le paramètre #:asd-system-name peut être utilisé pour spécifier le nom du système.

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.

It adds rustc and cargo to the set of inputs. A different Rust package can be specified with the #:rust parameter.

Regular cargo dependencies should be added to the package definition via the #:cargo-inputs parameter as a list of name and spec pairs, where the spec can be a package or a source definition. Note that the spec must evaluate to a path to a gzipped tarball which includes a Cargo.toml file at its root, or it will be ignored. Similarly, cargo dev-dependencies should be added to the package definition via the #:cargo-development-inputs parameter.

In its configure phase, this build system will make any source inputs specified in the #:cargo-inputs and #:cargo-development-inputs parameters available to cargo. It will also remove an included Cargo.lock file to be recreated by cargo during the build phase. The install phase installs any crate the binaries if they are defined by the crate.

Scheme Variable : copy-build-system

This variable is exported by (guix build-system copy). It supports builds of simple packages that don’t require much compiling, mostly just moving files around.

It adds much of the gnu-build-system packages to the set of inputs. Because of this, the copy-build-system does not require all the boilerplate code often needed for the trivial-build-system.

To further simplify the file installation process, an #:install-plan argument is exposed to let the packager specify which files go where. The install plan is a list of (source target [filters]). filters are optional.

Examples:

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.

This build system is an extension of ant-build-system, but with the following phases changed:

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

This phase installs all top-level files with base name matching %doc-regex. A different regex can be specified with the #:doc-regex parameter. All files (recursively) inside the documentation directories specified in #:doc-dirs are installed as well.

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+.

This build system adds the following two phases to the ones defined by gnu-build-system:

glib-or-gtk-wrap

La phase glib-or-gtk-wrap s’assure que les programmes dans bin/ sont capable de trouver les « schemas » GLib et les modules GTK+. Ceci est fait en enveloppant les programmes dans des scripts de lancement qui initialisent correctement 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.

Scheme Variable : 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 not run.

Julia packages require the source file-name to be the real name of the package, 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 : 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, le 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 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.

By default guix calls setup.py under control of setuptools, much like pip does. Some packages are not compatible with setuptools (and pip), thus you can disable this by setting the #:use-setuptools? parameter to #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 : qt-build-system

This variable is exported by (guix build-system qt). It is intended for use with applications using Qt or KDE.

This build system adds the following two phases to the ones defined by cmake-build-system:

check-setup

The phase check-setup prepares the environment for running the checks as commonly used by Qt test programs. For now this only sets some environment variables: QT_QPA_PLATFORM=offscreen, DBUS_FATAL_WARNINGS=0 and CTEST_OUTPUT_ON_FAILURE=1.

This phase is added before the check phase. It’s a separate phase to ease adjusting if necessary.

qt-wrap

The phase qt-wrap searches for Qt5 plugin paths, QML paths and some XDG in the inputs and output. In case some path is found, all programs in the output’s bin/, sbin/, libexec/ and lib/libexec/ directories are wrapped in scripts defining the necessary environment variables.

It is possible to exclude specific package outputs from that wrapping process by listing their names in the #:qt-wrap-excluded-outputs parameter. This is useful when an output is known not to contain any Qt binaries, and where wrapping would gratuitously add a dependency of that output on Qt, KDE, or such.

This phase is added after the install phase.

Variable Scheme : r-build-system

Cette variable est exportée par (guix build-system r). Elle implémente la procédure de construction utilisée par les paquets R qui consiste à lancer à peine plus que R CMD INSTALL --library=/gnu/store/… dans un environnement où R_LIBS_SITE contient les chemins de toutes les entrées R. Les tests sont lancés après l’installation avec la fonction R tools::testInstalledPackage.

Variable Scheme : rakudo-build-system

Cette variable est exportée par (guix build-system rakudo). Elle implémente la procédure de construction utilisée par Rakudo pour les paquets Perl6. Elle installe le paquet dans /gnu/store/…/NOM-VERSION/share/perl6 et installe les binaires, les fichiers de bibliothèques et les ressources, et enveloppe les fichiers dans le répertoire bin/. Les tests peuvent être passés en indiquant #f au paramètres tests?.

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.

Additional flags to be passed to scons can be specified with the #:scons-flags parameter. The default build and install targets can be overridden with #:build-targets and #:install-targets respectively. The version of Python used to run SCons can be specified by selecting the appropriate SCons package with the #:scons parameter.

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).

It first creates the package-autoloads.el file, then it byte compiles all Emacs Lisp files. Differently from the Emacs packaging system, the Info documentation files are moved to the standard documentation directory and the dir file is deleted. The Elisp package files are installed directly under 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.

This build system is an extension of gnu-build-system, but with the following phases changed to some specific for Meson:

configure

La phase lance meson avec les drapeaux spécifiés dans #:configure-flags. Le drapeau --build-type est toujours initialisé à plain à moins que quelque chose d’autre 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 allows building Linux kernel modules.

This build system is an extension of gnu-build-system, but with the following phases changed:

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 (dans la forme « arguments » d’un paquet utilisant le linux-module-build-system, utilisez la clef #:linux pour le spécifier).

Scheme Variable : node-build-system

This variable is exported by (guix build-system node). It implements the build procedure used by Node.js, which implements an approximation of the npm install command, followed by an npm test command.

Which Node.js package is used to interpret the npm commands can be specified with the #:node parameter which defaults to 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]

6.4 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 RPC. 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 des 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.0.1. 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 defaults to %default-socket-path, which is the normal location given the options that were passed to 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 du dépôt valide et #f sinon (un élément invalide peut exister sur le disque mais rester invalide, par exemple parce que c’est le résultat d’une construction annulé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.

Scheme Procedure : build-derivations store derivations [mode] Build derivations, a list of <derivation> objects,

.drv file names, or derivation/output pairs, using the specified mode(build-mode normal) by default.

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]

6.5 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 fini 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]

6.6 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 »16. 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 mproc17. 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

Lorsqu’on la lance à travers %state-monad, on obtient cet valeur d’état supplémentaire, qui est le nombre d’appels à 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 des accès au dépôt. Lorsque son effet est requis, une valeur de la monade du dépôt doit être « évaluée » en la passant à la procédure run-with-store (voir plus bas).

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.

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]

6.7 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 Scheme18 : 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.

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 dérivations : on peut définir des compilateurs capable « d’abaisser » d’autres objets de haut-niveau ou des fichiers dans le dépôt, pour que ces objets puissent aussi être insérés dans des gexps. Par exemple, des objets haut-niveau utiles qui pourraient être insérées dans une gexp sont les « objets simili-fichiers », qui rendent facile l’ajout de fichiers dans le dépôt et les références vers eux dans les 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 "mips64el-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 à l’exécution du type gexp? (voir plus bas).

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édure 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] [#:substitutable? #t] [#:properties '()] [#:guile-for-build #f]

Renvoie une dérivation name qui lance exp (une gexp) avec guile-for-build (une dérivation) sur system ; exp est stocké dans un fichier appelé script-name. Lorsque target est vraie, elle est utilisée comme triplet de cible de compilation croisée pour les paquets référencés par exp.

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)] Return an object representing local

file file to add to the store; this object can be used in a gexp. If file is a literal string denoting a relative file name, it is looked up relative to the source file where it appears; if file is not a literal string, it is looked up relative to the current working directory at run time. file will be added to the store under name–by default the base name of 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 [#:options '(#:local-build? #t)]

Renvoie un objet représentant un élément du dépôt name, un fichier ou un répertoire calculé par gexp. 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] Return an executable script name that runs exp using guile, with exp’s imported modules in its search path. Look up exp’s modules in 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 exp [#:splice? #f]

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.

Scheme Syntax : with-parameters ((parameter value) …) exp

This macro is similar to the parameterize form for dynamically-bound parameters (voir Parameters dans GNU Guile Reference Manual). The key difference is that it takes effect when the file-like object returned by exp is lowered to a derivation or store item.

A typical use of with-parameters is to force the system in effect for a given object:

(with-parameters ((%current-system "i686-linux"))
  coreutils)

The example above returns an object that corresponds to the i686 build of Coreutils, regardless of the current value of %current-system.

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 la dérivation ou l’élément du dépôt comme une valeur de %store-monad qui correspond à obj pour system, en compilant de manière croisée pour target si target est vrai. obj doit être un objet qui a un compilateur de gexp associé, comme un <package>.


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

6.8 Invoquer guix repl

La commande guix repl démarre un boucle lecture-évaluation-affichage Guile pour la programmation interactive (voir Using Guile Interactively dans GNU Guile Reference Manual). Comparé au lancement de la commande guile, guix repl garanti que tous les modules Guix et toutes ses dépendances sont disponibles dans le chemin de recherche. Vous pouvez l’utiliser de cette manière :

$ 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).

This allows users to define their own packages and make them visible to the command-line tool.

-q

Inhibit loading of the ~/.guile file. By default, that configuration file is loaded when spawning a guile REPL.


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

7 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]

7.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 pour différencier des paquets avec le même nom ou des variantes de paquets.

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]

7.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.

This option implies --no-offload, and it has no effect when connecting to a remote daemon with a 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.

Remarquez que, les résultats qui diffèrent ne sont pas gardés, donc vous devrez inspecter manuellement chaque erreur — p. ex. en gardant l’un des résultats avec guix archive --export (voir Invoquer guix archive), puis en reconstruisant, et enfin en comparant les deux résultats.

--no-offload

Do not use offload builds to other machines (voir Réglages du délestage du démon). That is, always build things locally instead of offloading builds to remote machines.

--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, les paramètres du démon sont 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, les paramètres du démon sont 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

Permet au plus n travaux de construction en parallèle. Voir --max-jobs, pour plus de détails sur cette option et l’option équivalente pour 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 un 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 commande guix qui peuvent effectuer des construction honorent 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]

7.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).

--with-source=source
--with-source=paquet=source
--with-source=paquet@version=source

Utiles 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, --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. À utilisez avec précaution !

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

This is similar to --with-branch, except that it builds from commit rather than the tip of a branch. commit must be a valid Git commit SHA1 identifier or a tag.


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

7.1.3 Options de construction supplémentaires

Les options de la ligne de commande ci-dessous sont spécifiques à guix build.

--quiet
-q

Construire en silence, 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+))
--manifest=manifest
-m manifest

Build all packages listed in the given manifest (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).

Note that guix build -S compiles the sources only of the specified packages. They do not include the sources of statically linked dependencies and by themselves are insufficient for reproducing the packages.

--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 réseau. C’est une extension de l’option --source et 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.

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 entièrement 32-bits. C’est une exemple d’utilisation de cette option sur les systèmes Linux, qui peuvent émuler plusieurs personnalités.

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 "mips64el-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 mips64el-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]

7.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 l’arborescence de construction 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 dedans (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 obtient 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]

7.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 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.

Instead of GUIX_PACKAGE_PATH, the command-line option --load-path=directory (or in short -L directory) allows you to add directory to the front of the package module search path and so make your own packages visible.


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

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

--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]

7.4 Invoquer guix hash

La commande guix hash calcul le hash SHA256 d’un fichier. C’est surtout un outil pour simplifier la vie des contributeurs de la distribution : il calcul 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 :

--format=fmt
-f fmt

Écrit le hash dans le format spécifié par fmt.

Les formats supportés sont : nix-base32, base32, base16 (hex et hexadecimal peuvent aussi ê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

Lorsqu’elle est combinée à --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]

7.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 specifies the source from which to import package metadata, and options specifies a package identifier and other options specific to importer.

Some of the importers rely on the ability to run the gpgv command. For these, GnuPG must be installed and in $PATH; run guix install gnupg if needed.

Currently, the available “importers” are:

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 les métadonnées du module Perl Acme::Boolean :

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.

Les informations sont extraites du fichier DESCRIPTION du paquet.

La commande ci-dessous importe les métadonnées du paquet R Cairo :

guix import cran Cairo

Lorsque l’option --recursive est utilisée, l’importateur traversera le graphe des dépendances du paquet amont récursivement et générera des expressions de paquets pour tous ceux qui ne sont pas déjà dans Guix.

Lorsque l’option --archive=bioconductor est utilisée, les métadonnées sont importées de Bioconductor, un répertoire de paquets R pour l’analyse et la compréhension de données génomiques volumineuses en bioinformatique.

Information is extracted from the DESCRIPTION file contained in the package archive.

La commande ci-dessous importe les métadonnées du paquet R GenomicRanges :

guix import cran --archive=bioconductor GenomicRanges

Finally, you can also import R packages that have not yet been published on CRAN or Bioconductor as long as they are in a git repository. Use --archive=git followed by the URL of the git repository:

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 utilisé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 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 Nixpkgs19. 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 de la dernière version du paquet Haskell HTTP sans inclure les dépendances des tests et en spécifiant la valeur du drapeau ‘network-uri’ comme étant 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 du paquet Haskell HTTP inclus dans la version LTS 7.18 de 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

Import metadata from the crates.io Rust package repository crates.io, as in this example:

guix import crate blake2-rfc

The crate importer also allows you to specify a version string:

guix import crate constant-time-eq@0.1.0

Additional options include:

--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.

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]

7.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

Autrement, on peut spécifier les paquets à considérer, auquel cas un avertissement est émis pour les paquets qui n’ont pas de gestionnaire de mise à jour associé :

$ 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")))))

When passed --update, it modifies distribution source files to update the version numbers and source tarball hashes of those package recipes (voir Définition des paquets). This is achieved by downloading each package’s latest source tarball and its associated OpenPGP signature, authenticating the downloaded tarball against its signature using gpgv, and finally computing its hash—note that GnuPG must be installed and in $PATH; run guix install gnupg if needed.

When the public key used to sign the tarball is missing from the user’s keyring, an attempt is made to automatically retrieve it from a public key server; when this is successful, the key is added to the user’s keyring; otherwise, guix refresh reports an error.

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 paquets qui dépendent de la libc « finale » (en gros 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

Choisi tous les paquets du manifeste dans file. C’est utile pour vérifier qu’aucun des paquets du manifeste utilisateur ne peut être mis à jour.

--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 ;

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 au-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 mise à jour et quitte (voir l’option --type plus haut).

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.

Soyez conscients que l’option --list-dependent ne fait qu’approximer les reconstructions qui seraient requises par une mise à jour. Plus de reconstructions pourraient être requises 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 porte-clefs pour les clefs de signature amont. Les signatures OpenPGP sont vérifiées avec ces clefs ; les clefs manquantes sont aussi téléchargées dans ce porte-clefs (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 l’API de GitHub pour faire des requêtes sur les nouvelles versions. Lorsqu’elle est utilisé de manière répétée, p. ex. 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 requiert bien plus que cela. 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]

7.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

Sonde les URL home-page et source et rapporte celles qui sont invalides. Suggère une URL en mirror:// lorsque c’est possible. Si l’URL de source redirige vers une URL GitHub, recommande d’utiliser l’URL GitHub. Vérifie que le nom du fichier source a un sens, p. ex. qu’il ne s’agisse pas juste d’un numéro de version ou « git-checkout », sans avoir déclaré un 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.

archival

Checks whether the package’s source code is archived at Software Heritage.

When the source code that is not archived comes from a version-control system (VCS)—e.g., it’s obtained with git-fetch, send Software Heritage a “save” request so that it eventually archives it. This ensures that the source will remain available in the long term, and that Guix can fall back to Software Heritage should the source code disappear from its original host. The status of recent “save” requests can be viewed on-line.

When source code is a tarball obtained with url-fetch, simply print a message when it is not archived. As of this writing, Software Heritage does not allow requests to save arbitrary tarballs; we are working on ways to ensure that non-VCS source code is also archived.

Software Heritage limits the request rate per IP address. When the limit is reached, guix lint prints a message and the archival checker stops doing anything until that limit has been reset.

cve

Report known vulnerabilities found in the Common Vulnerabilities and Exposures (CVE) databases of the current and past year 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.

Package developers can specify in package recipes the Common Platform Enumeration (CPE) name and version of the package when they differ from the name or version that Guix uses, as in this example:

(package
  (name "grub")
  ;; …
  ;; CPE calls this package "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.

--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]

7.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).

Lorsque les paquets passés à guix size sont disponibles dans le dépôt20, 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.

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]

7.9 Invoque guix graph

Les paquets et leurs dépendances forment un graphe, plus précisément un graphe orienté acyclique (DAG). Il peut vite devenir difficile d’avoir une représentation mentale du DAG d’un paquet, donc la commande guix graph fournit une représentation visuelle du DAG. Par défaut, guix graph émet un représentation du DAG dans le format d’entrée de Graphviz, pour que sa sortie puisse être passée directement à la commande dot de Graphviz. Elle peut aussi émettre une page HTML avec du code Javascript pour afficher un « digramme d’accords » dans un navigateur Web, grâce à la bibliothèque d3.js, ou émettre des requêtes Cypher pour construire un graphe dans une base de donnée de graphes supportant le langage de requêtes openCypher. La syntaxe générale est :

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 ?

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 vous intéressez aussi au cas où OCaml est une dépendance implicite, voir reverse-bag plus bas).

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 | dot -Tpdf > dag.pdf

… 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 | dot -Tpdf > module-graph.pdf

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é.

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.

--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.

On top of that, guix graph supports all the usual package transformation options (voir Options de transformation de paquets). This makes it easy to view the effect of a graph-rewriting transformation such as --with-input. For example, the command below outputs the graph of git once openssl has been replaced by libressl everywhere in the graph:

guix graph git --with-input=openssl=libressl

So many possibilities, so much fun!


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

7.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).

When guix publish runs, it spawns an HTTP server which allows anyone with network access to obtain substitutes from it. This means that any machine running Guix can also act as if it were a build farm, since the HTTP interface is compatible with Cuirass, the software behind the ci.guix.gnu.org build farm.

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). Comme guix publish utilise la clef 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 baisser ses privilèges le plus tôt possible.

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).

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é (voir Invoquer guix archive), le démon peut télécharger des substituts à partir de lui :

guix-daemon --substitute-urls=http://example.org:8080

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 un en-tête Content-Type ou Content-Encoding approprié. 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[=method[:level]]
-C [method[:level]]

Compress data using the given method and level. method is one of lzip and gzip; when method is omitted, gzip is used.

When level is zero, disable compression. The range 1 to 9 corresponds to different compression levels: 1 is the fastest, and 9 is the best (CPU-intensive). The default is 3.

Usually, lzip compresses noticeably better than gzip for a small increase in CPU usage; see benchmarks on the lzip Web page.

À 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.

This option can be repeated, in which case every substitute gets compressed using all the selected methods, and all of them are advertised. This is useful when users may not support all the compression methods: they can select the one they support.

--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) renvoie une erreur 404 et déclenche la création de l’archive — en calculant son .narinfo et en compressant l’archive au besoin. Une fois l’archive cachée 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.

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.

--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).

If you are instead running Guix on a “foreign distro”, follow these instructions:


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

7.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"
updating list of substitutes from 'https://ci.guix.gnu.org'... 100.0%
updating list of substitutes from 'https://guix.example.org'... 100.0%
/gnu/store/…-openssl-1.0.2d contents differ:
  local hash: 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q
  https://ci.guix.gnu.org/nar/…-openssl-1.0.2d: 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q
  https://guix.example.org/nar/…-openssl-1.0.2d: 1zy4fmaaqcnjrzzajkdn3f5gmjk754b43qkq47llbyak9z0qjyim
  differing files:
    /lib/libcrypto.so.1.1
    /lib/libssl.so.1.1

/gnu/store/…-git-2.5.0 contents differ:
  local hash: 00p3bmryhjxrhpn2gxs2fy0a15lnip05l97205pgbk5ra395hyha
  https://ci.guix.gnu.org/nar/…-git-2.5.0: 069nb85bv4d4a6slrwjdy8v1cn4cwspm3kdbmyb81d6zckj3nq9f
  https://guix.example.org/nar/…-git-2.5.0: 0mdqa9w1p6cmli6976v4wi0sw9r4p5prkj7lzfd1877wk11c9c73
  differing file:
    /libexec/git-core/git-fsck

/gnu/store/…-pius-2.1.1 contents differ:
  local hash: 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax
  https://ci.guix.gnu.org/nar/…-pius-2.1.1: 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax
  https://guix.example.org/nar/…-pius-2.1.1: 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs
  differing file:
    /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.

To find out what is wrong with this Git binary, the easiest approach is to run:

guix challenge git \
  --diff=diffoscope \
  --substitute-urls="https://ci.guix.gnu.org https://guix.example.org"

This automatically invokes diffoscope, which displays detailed information about files that differ.

Alternately, we can do something along these lines (voir Invoquer guix archive):

$ wget -q -O - https://ci.guix.gnu.org/nar/…-git-2.5.0 \
   | 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 fournit 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

Upon mismatches, show differences according to mode, one of:

simple (the default)

Show the list of files that differ.

diffoscope
command

Invoke Diffoscope, passing it two directories whose contents do not match.

When command is an absolute file name, run command instead of Diffoscope.

none

Do not show further details about the differences.

Thus, unless --diff=none is passed, guix challenge downloads the store items from the given substitute servers so that it can compare them.

--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]

7.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 SSH21. 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]

7.13 Invoquer guix container

Remarque : À la version 1.0.1, 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]

7.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… [packages…]

When packages is omitted, guix weather checks the availability of substitutes for all the packages, or for those specified with --manifest; otherwise it only considers the specified packages. It is also possible to query specific system types with --system. guix weather exits with a non-zero code when the fraction of available substitutes is below 100%.

The available options are listed below.

--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).

This option can be repeated several times, in which case the manifests are concatenated.

--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
    …

Ce que montre cet exemple est que kcoreaddons et probablement les 58 paquets qui en dépendent n’ont pas de substituts sur ci.guix.info ; de même pour qgpgme et les 46 paquets qui en dépendent.

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

Display the list of store items for which substitutes are missing.


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

7.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 question22. 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
ChildProcess: 20495: guix offload x86_64-linux 7200 1 28800
ChildProcess: 27733: guix offload x86_64-linux 7200 1 28800
ChildProcess: 27793: 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.

Les champs LockHeld montrent quels éléments du dépôt sont actuellement verrouillés par cette session, ce qui correspond aux éléments du dépôt qui sont en train d’être construits ou d’être substitués (le champ LockHeld n’est pas montré si guix processes n’est pas lancé en root). Enfin, en regardant le champ ChildProcess, on comprend que ces trois constructions sont déchargées (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 …

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

8 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]

8.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)

(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
                                    (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

The packages field lists packages that will be globally visible on the system, for all user accounts—i.e., in every user’s PATH environment variable—in addition to the per-user profiles (voir Invoquer guix package). The %base-packages variable provides all the tools one would expect for basic user and administrator tasks—including the GNU Core Utilities, the GNU Networking Utilities, the GNU Zile lightweight text editor, find, grep, etc. The example above adds GNU Screen to those, taken from the (gnu packages screen) module (voir Modules de paquets). The (list package output) syntax can be used to add a specific output of a package:

(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.

For example, suppose you want to modify guix-daemon and Mingetty (the console log-in) in the %base-services list (voir %base-services). To do that, you can write the following in your operating system declaration:

(define %my-services
  ;; Ma propre liste de services.
  (modify-services %base-services
    (guix-service-type config =>
                       (guix-configuration
                        (inherit config)
                        (use-substitutes? #f)
                        (extra-options '("--gc-keep-derivations"))))
    (mingetty-service-type config =>
                           (mingetty-configuration
                            (inherit config)))))
(operating-system
  ;; …
  (services %my-services))

This changes the configuration—i.e., the service parameters—of the guix-service-type instance, and that of all the mingetty-service-type instances in the %base-services list. Observe how this is accomplished: first, we arrange for the original configuration to be bound to the identifier config in the body, and then we write the body so that it evaluates to the desired configuration. In particular, notice how we use inherit to create a new configuration which has the same values as the old configuration, but with a few 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))

  (users (cons (user-account
                (name "bob")
                (comment "Alice's brother")
                (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 ratpoison suckless wm)
(use-package-modules bootloaders certs 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
                     ;; 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, for the exact list of services provided by %desktop-services. Voir Certificats X.509, for background information about the nss-certs package that is used here.

Again, %desktop-services is just a list of service objects. If you want to remove services from there, you can do so using the procedures for list filtering (voir SRFI-1 Filtering and Partitioning dans GNU Guile Reference Manual). For instance, the following expression returns a list that contains all the services in %desktop-services minus the Avahi service:

(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]

8.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 paquet d’un noyau de système d’exploitation à utiliser23.

kernel-loadable-modules (default: ’())

A list of objects (usually packages) to collect loadable kernel modules from–e.g. (list ddcci-driver-linux).

kernel-arguments (par défaut : '("quiet"))

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)

Ce champ spécifie la disposition du clavier à utiliser dans la console. Il peut être soit #f, auquel cas la disposition par défaut est utilisée (habituellement anglais américain), ou un enregistrement <keyboard-layout>.

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 (default: %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 de chaînes identifiant les périphériques ou les fichiers utilisé pour « l’espace d’échange » (voir Memory Concepts dans The GNU C Library Reference Manual). Par exemple, '("/dev/sda3") ou '("/swapfile"). Il est possible de spécifier un fichier d’échange sur un périphérique mappé, 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 (default: %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 composés d’un nom de fichier cible et d’un objet simili-fichier (voir file-like objects). Ce sont les fichiers squelettes qui seront ajoutés au répertoire personnel des comptes utilisateurs 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 (default: %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 (default: %base-packages)

L’ensemble des paquets installés dans le profil global, qui est accessible à partir de /run/current-system/profile.

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 (default: %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 (default: %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 (default: %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]

8.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érique24.

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 uuid25, 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 : '())

This is a list of symbols denoting mount flags. Recognized flags include read-only, bind-mount, no-dev (disallow access to special files), no-suid (ignore setuid and setgid bits), no-atime (do not update file access times), strict-atime (update file access time), lazy-time (only update time on the in-memory version of the file inode), and no-exec (disallow program execution). Voir Mount-Unmount-Remount dans The GNU C Library Reference Manual, for more information on these flags.

options (par défaut : #f)

Cela vous soit #f soit il s’agit d’une chaîne dénotant des options à passer au pilote du système de fichiers. Voir Mount-Unmount-Remount dans The GNU C Library Reference Manual, pour des détails et lancez man 8 mount pour trouver des options pour divers systèmes de fichiers.

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

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).

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é.


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

8.4 Périphériques mappés

Le noyau Linux a une notion de mappage de périphériques : un périphérique bloc, comme une partition sur un disque dur, peut être mappé sur un autre périphérique, typiquement dans /dev/mapper, avec des calculs supplémentaires sur les données qui naviguent entre les deux26. Un exemple typique est le mappage de périphériques chiffrés : toutes les écritures sont sur le périphérique mappé sont chiffrées, toutes les lectures déchiffrées, de manière transparente. Guix étend cette notion en considérant que tout périphérique ou ensemble de périphériques qui sont transformés d’une certaine manière créent un nouveau périphérique ; par exemple, les périphériques RAID sont obtenus en assemblant plusieurs autres périphériques, comme des disque ou des partitions, en un nouveau périphérique en tant qu’unique partition. Un autre exemple, qui n’est pas encore disponible, sont les volumes logiques LVM.

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

C’est soit une chaîne qui spécifie le nom d’un périphérique bloc à mapper, comme "/dev/sda3", soit une liste de plusieurs périphériques à assembler pour en créer un nouveau.

target

Cette chaîne spécifie le nom du périphérique mappé qui en résulte. Pour les mappeurs noyaux comme les périphériques chiffrés de type luks-device-mapping, spécifier "ma-partition" crée le périphérique "/dev/mapper/ma-partition". Pour les périphériques RAID de type raid-device-mapping, il faut donner le nom complet comme "/dev/md0".

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.

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.


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

8.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")
  (home-directory "/home/alice"))

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énote un nom de fichier d’un programme utilisé comme shell (voir G-Expressions).

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 :

(user-account
  (name "charlie")
  (group "users")

  ;; Spécifie un mot de passe initial hashé avec sha512.
  (password (crypt "InitialPassword!" "$6$abc")))

Remarque : Le hash de ce mot de passe initial sera disponible dans un fichier dans /gnu/store, lisible par tous les utilisateurs, donc cette méthode est à utiliser avec soin.

Voir Passphrase Storage dans The GNU C Library Reference Manual, pour plus d’information sur le chiffrement des mots de passe et Encryption dans GNU Guile Reference Manual, pour des informations sur la procédure crypt de Guile.

Les déclarations de groupes sont encore plus simple :

(user-group (name "students"))
Type de données : user-group

C’est le type pour, hé bien, les comptes utilisateurs. Il n’y a que quelques champs :

name

Le nom du groupe.

id (par défaut : #f)

L’identifiant du groupe (un nombre). S’il est #f, un nouveau nombre est alloué automatiquement lorsque le groupe est créé.

system? (par défaut : #f)

Cette valeur booléenne indique si le groupe est un groupe « système ». les groupes systèmes ont un numéro d’ID bas.

password (par défaut : #f)

Quoi, les groupes utilisateurs peuvent avoir des mots de passe ? On dirait bien. À moins que la valeur ne soit #f, ce champ spécifie le mot de passe du groupe.

Par simplicité, une variable liste les groupes utilisateurs de base auxquels on pourrait s’attendre :

Variable Scheme : %base-groups

C’est la liste des groupes utilisateur de base que les utilisateurs et les paquets s’attendent à trouver sur le système. Cela comprend des groupes comme « root », « wheel » et « users », ainsi que des groupes utilisés pour contrôler l’accès à certains périphériques, comme « audio », « disk » et « cdrom ».

Variable Scheme : %base-user-accounts

C’est la liste des compte du système de base que les programmes peuvent s’attendre à trouver sur un système GNU/Linux, comme le compte « nobody ».

Remarquez que le compte « root » n’est pas défini ici. C’est un cas particulier et il est automatiquement ajouté qu’il soit spécifié ou non.


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

8.6 Disposition du clavier

Pour spécifier ce que fait chaque touche de votre clavier, vous devez dire au système d’exploitation quel disposition du clavier vous voulez utiliser. Par défaut, lorsque rien n’est spécifié, la disposition QWERTY pour l’anglais américain pour les claviers 105 touches est utilisée. Cependant, les germanophones préfèrent généralement la disposition QWERTZ, les francophones la disposition AZERTY etc. ; les hackers peuvent préférer Dvorak ou bépo, et peuvent même vouloir personnaliser plus en détails l’effet de certaines touches. Cette section explique comment faire cela.

Il y a trois composants qui devront connaître votre disposition du clavier :

Guix vous permet de configurer les trois séparément mais, heureusement, il vous permet de partager la même disposition du clavier pour chacun des trois composants.

Les dispositions de clavier sont représentées par des enregistrements créés par la procédure keyboard-layout de (gnu system keyboard). En suivant l’extension clavier de X (XKB), chaque disposition a trois attributs : un nom (souvent un code de langue comme « fi » pour le finnois ou « jp » pour le japonais), un nom de variante facultatif, un nom de modèle de clavier facultatif et une liste éventuellement vide d’options supplémentaires. Dans la plupart des cas, vous n’aurez besoin que du nom de la disposition. Voici quelques exemples :

;; La disposition QWERTZ allemande.  Ici on suppose que vous utilisez un clavier
;; type « pc105 » standard.
(keyboard-layout "de")

;; La variante bépo de la disposition française.
(keyboard-layout "fr" "bepo")

;; La disposition catalane.
(keyboard-layout "es" "cat")

;; Arabic layout with "Alt-Shift" to switch to US layout.
(keyboard-layout "ar,us" #:options '("grp:alt_shift_toggle"))

;; La disposition espagnole américaine.  En plus, la touche
;; « Verr. Maj. » est utilisée comme touche « Ctrl » supplémentaire,
;; et la touche « Menu » est utilisée comme touche « Compose » pour
;; saisir des lettres accentuées.
(keyboard-layout "latam"
                 #:options '("ctrl:nocaps" "compose:menu"))

;; La disposition russe pour un clavier de ThinkPad.
(keyboard-layout "ru" #:model "thinkpad")

;; La disposition « US internationale », qui est comme la disposition US plus
;; des touches mortes pour saisir des caractères accentués.  Cet exemple est pour
;; un clavier de MacBook Apple.
(keyboard-layout "us" "intl" #:model "macbook78")

Voir le répertoire share/X11/xkb du paquet xkeyboard-config pour une liste complète des disposition, des variantes et des modèles pris en charge.

Disons que vous voulez que votre système utilise la disposition turque sur tout le système — du chargeur d’amorçage à Xorg en passant par la console. Voici ce que votre configuration du système contiendrait :

;; Utiliser la disposition turque pour le chargeur d'amorçage,
;; la console et Xorg.
(operating-system
  ;; ...
  (keyboard-layout (keyboard-layout "tr"))  ;pour la console
  (bootloader (bootloader-configuration
                (bootloader grub-efi-bootloader)
                (target "/boot/efi")
                (keyboard-layout keyboard-layout))) ;pour GRUB
  (services (cons (set-xorg-configuration
                    (xorg-configuration             ;pour Xorg
                      (keyboard-layout keyboard-layout)))
                  %desktop-services)))

Dans l’exemple ci-dessus, pour GRUB et pour Xorg, nous nous référons simplement au champ keyboard-layout au dessus, mais on pourrait aussi bien se référer à une autre disposition. La procédure set-xorg-configuration communique la configuration Xorg désirée au gestionnaire de connexion, par défaut GDM.

Nous avons discuté de la manière de spécifier la disposition du clavier par défaut lorsque votre système démarre, mais vous pouvez aussi l’ajuster à l’exécution :


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

8.7 Régionalisation

Un paramètre linguistique définie les conventions culturelles d’une langue et d’une région particulières (voir Régionalisation dans The GNU C Library Reference Manual). Chaque paramètre linguistique a un nom de la forme langue_territoire.jeudecaractères — p. ex. fr_LU.utf8 désigne le paramètre linguistique pour le français, avec les conventions culturelles du Luxembourg, en utilisant l’encodage UTF-8.

Normalement, vous voudrez spécifier les paramètres linguistiques par défaut pour la machine en utilisant le champ locale de la déclaration operating-system (voir locale).

Les paramètres régionaux choisis sont automatiquement ajoutés aux définitions des paramètres régionaux connues par le système au besoin, avec le jeu de caractères inféré à partir de son nom, p. ex. bo_CN.utf8 supposera qu’il faut utiliser le jeu de caractères UTF-8. Des définitions supplémentaires peuvent être spécifiées dans le champ locale-definitions de operating-system — c’est utile par exemple si le jeu de caractères n’a pas été inféré à partir du nom. L’ensemble par défaut de définitions comprend certains paramètres linguistiques parmi les plus utilisés, mais pas toutes les variantes disponibles, pour gagner de la place.

Par exemple, pour ajouter les paramètres pour le frison septentrional en Allemagne, la valeur de ce champ serait :

(cons (locale-definition
        (name "fy_DE.utf8") (source "fy_DE"))
      %default-locale-definitions)

De me, pour gagner de la place, on peut vouloir lister dans locale-definitions seulement les paramètres qui sont vraiment utilisés, comme dans :

(list (locale-definition
        (name "ja_JP.eucjp") (source "ja_JP")
        (charset "EUC-JP")))

Les définitions des paramètres linguistiques compilées sont disponibles dans /run/current-system/locale/X.Y, où X.Y est la version de la libc, ce qui est l’emplacement par défaut où la GNU libc fournie par Guix cherche les données de régionalisation. Cet emplacement peut être modifié avec la variable d’environnement LOCPATH (voir LOCPATH and locale packages).

La forme locale-definition est fournie par le module (gnu system locale). Des détails sont disponibles plus bas.

Type de données : locale-definition

C’est le type de données d’une définition de paramètres linguistiques.

name

Le nom du paramètre linguistique. Voir Locale Names dans The GNU C Library Reference Manual, pour en savoir plus sur les noms de paramètres linguistiques.

source

Le nom de la source pour ce paramètre linguistique. C’est typiquement la partie langue_territoire du nom du paramètre.

charset (par défaut : "UTF-8")

Le « jeu de caractères » d’un paramètre linguistique, défini par l’IANA.

Variable Scheme : %default-locale-definitions

Une liste des paramètres linguistiques UTF-8 couramment utilisés, utilisée comme valeur par défaut pour le champ locale-definitions des déclarations operating-system.

Ces définitions de paramètres linguistiques utilisent le jeu de caractère normalisé pour la partie qui suit le point dans le nom (voir normalized codeset dans The GNU C Library Reference Manual). Donc par exemple il y a uk_UA.utf8 mais pas, disons, uk_UA.UTF-8.

8.7.1 Considérations sur la compatibilité des données linguistiques

Les déclaration operating-system fournissent un champ locale-libcs pour spécifier les paquets GNU libc à utiliser pour compiler les déclarations de paramètres linguistiques (voir Référence de système d'exploitation). « Pourquoi je devrais m’en soucier ? », vous demandez-vous sûrement. Hé bien il se trouve que le format binaire des données linguistique est parfois incompatible d’une version de la libc à une autre.

Par exemple, un programme lié à la libc version 2.21 est incapable de lire les données linguistiques produites par la libc 2.22 ; pire, ce programme plante plutôt que d’ignorer les données linguistiques incompatibles27. De même, un programme lié à la libc 2.22 peut lire la plupart mais pas toutes les données linguistiques de la libc 2.21 (spécifiquement les données LC_COLLATE sont incompatibles) ; donc les appels à setlocale peuvent échouer, mais les programmes ne plantent pas.

Le « problème » avec Guix c’est que les utilisateurs ont beaucoup de liberté : ils peuvent choisir s’ils veulent et quand ils veulent mettre à jour les logiciels de leur profil, et peuvent utiliser une version différente de la libc de celle que l’administrateur système utilise pour construire les données linguistiques du système global.

Heureusement, les utilisateurs non privilégiés peuvent aussi installer leur propres données linguistiques et définir GUIX_LOCPATH comme il le faut (voir GUIX_LOCPATH and locale packages).

Cependant, c’est encore mieux si les données linguistiques du système dans /run/current-system/locale étaient construites avec les versions de la libc utilisées sur le système, pour que tous les programmes puissent y accéder — c’est surtout crucial sur un système multi-utilisateurs. Pour cela, l’administrateur peut spécifier plusieurs paquets de la libc dans le champ locale-libcs de operating-system :

(use-package-modules base)

(operating-system
  ;; …
  (locale-libcs (list glibc-2.21 (canonical-package glibc))))

Cet exemple créera un système contenant les définitions des paramètres linguistiques pour la libc 2.21 et pour la version actuelle de la libc dans /run/current-system/locale.


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

8.8 Services

Une part importante de la préparation d’une déclaration operating-system est la liste des services systèmes et de leur configuration (voir Utiliser le système de configuration). Les services systèmes sont typiquement des démons lancés au démarrage ou d’autres actions requises à ce moment-là — p. ex. configurer les accès réseaux.

Guix a une définition large de « service » (voir Composition de services), mais beaucoup de services sont gérés par le GNU Shepherd (voir Services Shepherd). Sur un système lancé, la commande herd vous permet de lister les services disponibles, montrer leur statut, les démarrer et les arrêter, ou faire d’autres opérations spécifiques (voir Jump Start dans The GNU Shepherd Manual). Par exemple :

# herd status

La commande ci-dessus, lancée en root, liste les services actuellement définis. La commande herd doc montre un synopsis du service donné et ses actions associées :

# herd doc nscd
Run libc's name service cache daemon (nscd).

# herd doc nscd action invalidate
invalidate: Invalidate the given cache--e.g., 'hosts' for host name lookups.

Les sous-commandes start, stop et restart ont l’effet auquel on s’attend. Par exemple, les commande suivantes stoppent le service nscd et redémarrent le serveur d’affichage Xorg :

# herd stop nscd
Service nscd has been stopped.
# herd restart xorg-server
Service xorg-server has been stopped.
Service xorg-server has been started.

Les sections suivantes documentent les services disponibles, en commençant par les services de base qui peuvent être utilisés avec une déclaration operating-system.


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

8.8.1 Services de base

Le module (gnu services base) fournit des définitions de services pour les services de base qu’on peut attendre du système. Les services exportés par ce module sort listés ci-dessous.

Variable Scheme : %base-services

Cette variable contient une liste de services de base (voir Types service et services, pour plus d’informations sur les objets service) qu’on peut attendre du système : un service de connexion (mingetty) sur chaque tty, syslogd, le démon de cache de noms de la libc (nscd), le gestionnaire de périphériques udev, et plus.

This is the default value of the services field of operating-system declarations. Usually, when customizing a system, you will want to append services to %base-services, like this:

(append (list (service avahi-service-type)
              (service openssh-service-type))
        %base-services)
Variable Scheme : special-files-service-type

C’est le service qui met en place des « fichiers spéciaux » comme /bin/sh ; une instance de ce service fait partie de %base-services.

La valeur associée avec les services special-files-service-type doit être une liste de couples dont le premier élément est le « fichier spécial » et le deuxième sa cible. Par défaut il s’agit de :

`(("/bin/sh" ,(file-append bash "/bin/sh")))

Si vous voulez ajouter, disons, /usr/bin/env à votre système, vous pouvez changer cela en :

`(("/bin/sh" ,(file-append bash "/bin/sh"))
  ("/usr/bin/env" ,(file-append coreutils "/bin/env")))

Comme il fait parti de %base-services, vous pouvez utiliser modify-services pour personnaliser l’ensemble des fichiers spéciaux (voir modify-services). Mais une manière plus simple d’ajouter un fichier spécial est d’utiliser la procédure extra-special-file (voir plus bas).

Procédure Scheme : extra-special-file file target

Utilise target comme « fichier spécial » file.

Par exemple, ajouter l’une des lignes suivantes au champ services de votre déclaration de système d’exploitation crée un lien symbolique /usr/bin/env :

(extra-special-file "/usr/bin/env"
                    (file-append coreutils "/bin/env"))
Procédure Scheme : host-name-service name

Renvoie un service qui paramètre le nom d’hôte à name.

Scheme Variable : console-font-service-type

Install the given fonts on the specified ttys (fonts are per virtual console on the kernel Linux). The value of this service is a list of tty/font pairs. The font can be the name of a font provided by the kbd package or any valid argument to setfont, as in this example:

`(("tty1" . "LatGrkCyr-8x16")
  ("tty2" . ,(file-append
                font-tamzen
                "/share/kbd/consolefonts/TamzenForPowerline10x20.psf"))
  ("tty3" . ,(file-append
                font-terminus
                "/share/consolefonts/ter-132n"))) ; for HDPI
Procédure Scheme : login-service config

Renvoie un service pour lancer login en suivant config, un objet <login-configuration> qui spécifie le message du jour, entre autres choses.

Type de données : login-configuration

Le type de données qui représente la configuration de login.

motd

Un objet simili-fichier contenant le « message du jour ».

allow-empty-passwords? (par défaut : #t)

Permet les mots de passes vides par défaut pour que les utilisateurs puissent se connecter au compte « root » la première fois après sa création.

Procédure Scheme : mingetty-service config

Renvoie un service qui lance mingetty en suivant config, un objet <mingetty-configuration>, qui spécifie le tty à lancer entre autres choses.

Type de données : mingetty-configuration

C’est le type de données représentant la configuration de Mingetty, qui fournit l’implémentation par défaut de l’écran de connexion des consoles virtuelles.

tty

Le nom de la console sur laquelle tourne ce Mingetty, p. ex. "tty1".

auto-login (par défaut : #f)

Lorsque la valeur est vraie, ce champ doit être une chaîne de caractère dénotant le nom d’utilisateur pour lequel le système se connecte automatiquement. Lorsque la valeur est #f, il faut entrer un nom d’utilisateur et un mot de passe pour se connecter.

login-program (par défaut : #f)

Ce doit être soit #f, auquel cas le programme de connexion par défaut est utilisé (login de la suite d’outils Shadow), soit une gexp dénotant le nom d’un programme de connexion.

login-pause? (par défaut : #f)

Lorsque la valeur est #t en plus de auto-login, l’utilisateur devrai appuyer sur une touche avant que le shell de connexion ne soit lancé.

mingetty (par défaut : mingetty)

Le paquet Mingetty à utiliser.

Procédure Scheme : agetty-service config

Renvoie un service pour lancer agetty en suivant config, un objet <agetty-configuration>, qui spécifie le tty à lancer, entre autres choses.

Type de données : agetty-configuration

Ce type de données représente la configuration de agetty, qui implémente l’écran de connexion des consoles virtuelles et series. Voir la page de manuel de agetty(8) pour plus d’informations.

tty

Le nom de la console sur laquelle agetty est lancé p. ex. "ttyS0". Cet argument est facultatif, il aura par défaut une valeur raisonnable d’un port série utilisé par le noyau Linux.

Pour cela, s’il y a une valeur pour une option agetty.tty sur la ligne de commande du noyau, agetty extraira le nom du périphérique du port série à partir de cette option.

Sinon et s’il y a une valeur pour une option console avec un tty sur la ligne de commande du noyau Linux, agetty extraira le nom du périphérique du port série et l’utilisera.

Dans les deux cas, agetty laissera les autres paramètres du périphérique série (baud, etc.) sans y toucher — dans l’espoir que Linux leur a assigné les bonnes valeurs.

baud-rate (par défaut : #f)

Une chaîne qui contient une liste d’un ou plusieurs taux de baud séparés par des virgules, en ordre décroissant.

term (par défaut : #f)

Une chaîne contenant la valeur utilisée pour la variable d’environnement TERM.

eight-bits? (par défaut : #f)

Lorsque la valeur est #t, le tty est supposé être propre pour les caractères 8-bit et la détection de parité est désactivée.

auto-login (par défaut : #f)

Lorsqu’un nom de connexion est passé comme une chaîne de caractères, l’utilisateur spécifié sera automatiquement connecté sans demande du nom d’utilisateur ni du mot de passe.

no-reset? (par défaut : #f)

Lorsque la valeur est #t, ne vide pas les cflags du terminal (modes de contrôle).

host (par défaut : #f)

Cette option accepte une chaîne contenant le « login_host », qui sera écrit dans le fichier /var/run/utmpx.

remote? (par défaut : #f)

Lorsque la valeur est #t en plus de host, cette option ajoutera une option fakehost -r à la ligne de commande du programme de connexion spécifié dans login-program.

flow-control? (par défaut : #f)

Lorsque la valeur est #t, active le contrôle de flux matériel (RTS/CTS).

no-issue? (par défaut : #f)

Lorsque la valeur est #t, le contenu du fichier /etc/issue ne sera pas affiché avant de présenter l’écran de connexion.

init-string (par défaut : #f)

Cette option accepte une chaîne de caractères qui sera envoyée au tty ou au modem avant toute autre chose. Elle peut être utilisée pour initialiser un modem.

no-clear? (par défaut : #f)

Lorsque la valeur est #t, agetty ne nettoiera pas l’écran avant de montrer l’écran de connexion.

login-program (par défaut : (file-append shadow "/bin/login"))

Cette option doit être soit une gexp dénotant le nom d’un programme de connexion, soit non définie, auquel cas la valeur par défaut est la commande login de la suite d’outils Shadow.

local-line (par défaut : #f)

Contrôle le drapeau CLOCAL. Cette option accepte l’un des trois symboles comme argument, 'auto, 'always ou 'never. Si la valeur est #f, la valeur par défaut choisie par agetty est 'auto.

extract-baud? (par défaut : #f)

Lorsque la valeur est #t, dit à agetty d’essayer d’extraire la taux de baud depuis les messages de statut produits par certains modems.

skip-login? (par défaut : #f)

Lorsque la valeur est #t, ne demande par de nom d’utilisateur. Elle peut être utilisée avec le champ login-program pour utiliser des systèmes de connexion non standards.

no-newline? (par défaut : #f)

Lorsque la valeur est #t, n’affiche pas de retour à la ligne avant d’afficher le fichier /etc/issue.

login-options (par défaut : #f)

Cette option accepte une chaîne de caractères contenant des options passées au programme login. Lorsqu’utilisé avec login-program, soyez conscient qu’un utilisateur malicieux pourrait essayer de rentrer un nom d’utilisateur contenant des options incluses qui pourraient être analysées par le programme de connexion.

login-pause (par défaut : #f)

Lorsque la valeur est #t, attend qu’une touche soit appuyée avant de montrer l’écran de connexion. Cela peut être utilisé avec auto-login pour sauvegarder de la mémoire en lançant les shells de manière fainéante.

chroot (par défaut : #f)

Change de racine dans le répertoire donné. Cette option accepte un chemin en tant que chaîne de caractères.

hangup? (par défaut : #f)

Utilise l’appel système Linux vhangup pour raccrocher virtuellement le terminal spécifié.

keep-baud? (par défaut : #f)

Lorsque la valeur est #t, essaye de garder le taux de baud existant. Les taux de baud de baud-rate sont utilisés lorsque agetty reçoit un caractères BREAK.

timeout (par défaut : #f)

Lorsque la valeur est un nombre entier, termine la session si aucun nom d’utilisateur n’a pu être lu après timeout secondes.

detect-case? (par défaut : #f)

Lorsque la valeur est #t, active le support pour la détection des terminaux en majuscule uniquement. Ce paramètre détectera qu’un nom d’utilisateur qui ne contient que des majuscules indique un terminal en majuscule et effectuera des conversion de majuscule en minuscule. Remarquez que cela ne fonctionne pas avec les caractères unicode.

wait-cr? (par défaut : #f)

Lorsque la valeur est #t, attend que l’utilisateur ou le modem envoie un retour chariot ou un saut de ligne avant d’afficher /etc/issue ou l’écran de connexion. Cela est typiquement utilisé avec l’option init-string.

no-hints? (par défaut : #f)

Lorsque la valeur est #t, n’affiche par les astuces à propos des verrouillages numériques, majuscule et défilement.

no-hostname? (par défaut : #f)

Par défaut, le nom d’hôte est affiché. Lorsque la valeur est #t, aucun nom d’hôte ne sera affiché.

long-hostname? (par défaut : #f)

Par défaut, le nom d’hôte n’est affiché qu’après le premier point. Lorsque la valeur est #t, le nom d’hôte pleinement qualifié renvoyé par gethostname ou getaddrinfo sera affiché.

erase-characters (par défaut : #f)

Cette option accepte une chaîne de caractères de caractères supplémentaires qui devraient être interprétés comme des effacements lorsque l’utilisateur les tape dans leur nom d’utilisateur.

kill-characters (par défaut : #f)

Cette option accepte une chaîne de caractères qui devrait être interprété comme signifiant « ignore tous les caractères précédent » (aussi appelé un caractère « kill ») lorsque l’utilisateur tape son nom d’utilisateur.

chdir (par défaut : #f)

Cette option accepte, en tant que chaîne de caractères, un chemin vers un répertoire dans lequel se trouvera la commande avant la connexion.

delay (par défaut : #f)

Cette option accepte, en tant qu’entier, le nombre de secondes à attendre avant d’ouvrir le tty et afficher l’écran de connexion.

nice (par défaut : #f)

Cette option accepte, en tant qu’entier, la valeur « nice » avec laquelle le programme login tourne.

extra-options (par défaut : '())

Cette option fournie un « mécanisme de secours » pour que l’utilisateur puisse ajouter des arguments de la ligne de commande arbitraires à agetty comme une liste de chaînes de caractères.

Procédure Scheme : kmscon-service-type config

Renvoie un service qui lance kmscon d’après config, un objet <kmscon-configuration>, qui spécifie le tty sur lequel tourner, entre autres choses.

Type de données : kmscon-configuration

C’est le type de données représentant la configuration de Kscon, qui implémente l’écran de chargement de la console virtuelle.

virtual-terminal

Le nom de la console sur laquelle Kmscon tourne, p. ex. "tty1".

login-program (par défaut : #~(string-append #$shadow "/bin/login"))

Une gexp qui dénote le nom d’un programme de connexion. le programme de connexion par défaut est login de la suite d’outils Shadow.

login-arguments (par défaut : '("-p"))

Une liste d’arguments à passer à login.

auto-login (par défaut : #f)

Lorsqu’un nom de connexion est passé comme une chaîne de caractères, l’utilisateur spécifié sera automatiquement connecté sans demande du nom d’utilisateur ni du mot de passe.

hardware-acceleration? (par défaut : #f)

S’il faut utiliser l’accélération matérielle.

kmscon (par défaut : kmscon)

Le paquet Kmscon à utiliser.

Procédure Scheme : nscd-service [config] [#:glibc glibc] [#:name-services '()]

Renvoie un service qui lance le démon de cache de services de noms de la libc (nscd) avec la config donnée — un objet <nscd-configuration>. Voir Name Service Switch, pour un exemple.

Parce que c’est pratique, le service du Shepherd pour nscd fournit les actions suivantes :

invalidate

Cela invalide le cache donné. Par exemple, en laçant :

herd invalidate nscd hosts

on invalide le cache de noms d’hôtes de nscd.

statistiques

Lancer herd statistics nscd affiche des informations sur l’utilisation de nscd et des caches.

Variable Scheme : %nscd-default-configuration

C’est la valeur par défaut de <nscd-configuration> (voir plus bas) utilisée par nscd-service. Elle utilise les caches définis par %nscd-default-caches ; voir plus bas.

Type de données : nscd-configuration

C’est le type de données qui représente la configuration du démon de cache de services de noms (nscd).

name-services (par défaut : '())

Liste des paquets dénotant des services de noms qui doivent être visible pour nscd, p. ex. (list nss-mdns).

glibc (par défaut : glibc)

Objet de paquet qui dénote la Bibliothèque C de GNU qui fournit la commande nscd.

log-file (par défaut : "/var/log/nscd.log")

Nom du fichier journal de nscd. C’est là que les sorties de débogage sont envoyée lorsque debug-level est strictement positif.

debug-level (par défaut : 0)

Entier qui dénote le niveau de débogage. Les entiers les plus grands signifient plus de sortie de débogage.

caches (par défaut : %nscd-default-caches)

Liste d’objets <nscd-cache> qui dénotent des choses à mettre en cache ; voir plus bas.

Type de données : nscd-cache

Type de données représentant une base de données de cache de nscd et ses paramètres.

database

C’est un symbole qui représente le nom de la base de donnée à mettre en cache. Les valeurs valide sont passwd, group, hosts et services qui désignent les bases de données NSS correspondantes (voir NSS Basics dans The GNU C Library Reference Manual).

positive-time-to-live
negative-time-to-live (par défaut : 20)

Un entier qui représente le nombre de secondes pendant lesquelles un résultat positif ou négatif reste en cache.

check-files? (par défaut : #t)

Indique s’il faut vérifier des mises à jours dans les fichiers correspondant à database.

Par exemple, lorsque database est hosts, ce drapeau indique à nscd de vérifier s’il y a des mises à jour de /etc/hosts et de les prendre en compte.

persistent? (par défaut : #t)

Indique si le cache devrait être stocké de manière persistante sur le disque.

shared? (par défaut : #t)

Indique si le cache devrait être partagé entre les utilisateurs.

max-database-size (par défaut : 32 MiB)

Taille maximale en octets de la base de données en cache.

Variable Scheme : %nscd-default-caches

Liste d’objets <nscd-cache> utilisés par défaut par nscd-configuration (voir plus haut).

Elle active la mise en cache persistante et agressive des recherches de services et de noms d’hôtes. Ces derniers fournissent une recherche de noms d’hôtes plus performante, résiliente face à des serveurs de noms peu fiables et une protection de votre vie privée plus efficace — souvent le résultat des recherches de noms d’hôtes sont dans le cache local, donc les serveurs de nom externes n’ont même pas besoin d’être questionnés.

Type de données : syslog-configuration

Ce type de données représente la configuration du démon syslog.

syslogd (par défaut : #~(string-append #$inetutils "/libexec/syslogd"))

Le démon syslog à utiliser.

config-file (par défaut : %default-syslog.conf)

Le fichier de configuration de syslog à utiliser.

Procédure Scheme : syslog-service config

Renvoie un service qui lance un démon syslog en suivant config.

Voir syslogd invocation dans GNU Inetutils, pour plus d’informations sur la syntaxe du fichier de configuration.

Variable Scheme : guix-service-type

C’est le type de service qui lance le démon de construction, guix-daemon (voir Invoquer guix-daemon). Sa valeur doit être un enregistrement guix-configuration décrit plus bas.

Type de données : guix-configuration

Ce type de données représente la configuration du démon de construction de Guix. Voir Invoquer guix-daemon pour plus d’informations.

guix (par défaut : guix)

Le paquet Guix à utiliser.

build-group (par défaut : "guixbuild")

Nom du groupe des comptes utilisateurs de construction.

build-accounts (par défaut : 10)

Nombre de comptes utilisateurs de construction à créer.

authorize-key? (par défaut : #t)

Indique s’il faut autoriser ou non les clefs de substituts listées dans authorize-keys — par défaut celle de ci.guix.gnu.org (voir Substituts).

authorized-keys (default: %default-authorized-guix-keys)

La liste des fichiers de clefs autorisées pour les imports d’archives, en tant que liste de gexps sous forme de chaînes (voir Invoquer guix archive). Par défaut, elle contient celle de ci.guix.gnu.org (voir Substituts).

use-substitutes? (par défaut : #t)

S’il faut utiliser les substituts.

substitute-urls (default: %default-substitute-urls)

La liste des URL où trouver des substituts par défaut.

max-silent-time (par défaut : 0)
timeout (par défaut : 0)

Le nombre de secondes de silence et le nombre de secondes d’inactivité, respectivement, après lesquelles un processus de construction son délai d’attente. Une valeur de zéro désactive le délai d’attente.

log-compression (par défaut : 'bzip2)

Le type de compression utilisé par les journaux de construction — parmi gzip, bzip2 et none.

extra-options (par défaut : '())

Liste d’options supplémentaires de la ligne de commande pour guix-daemon.

log-file (par défaut : "/var/log/guix-daemon.log")

Le fichier où les sorties standard et d’erreur de guix-daemon sont écrites.

http-proxy (par défaut : #f)

The URL of the HTTP and HTTPS proxy used for downloading fixed-output derivations and substitutes.

It is also possible to change the daemon’s proxy at run time through the set-http-proxy action, which restarts it:

herd set-http-proxy guix-daemon http://localhost:8118

To clear the proxy settings, run:

herd set-http-proxy guix-daemon
tmpdir (par défaut : #f)

Un répertoire où guix-daemon effectuera ses constructions.

Procédure Scheme : udev-service [#:udev eudev #:rules '()]

Lance udev, qui rempli le répertoire /dev dynamiquement. Les règles udev peuvent être fournies comme une liste de fichier via la variable rules. Les procédures udev-rule et file->udev-rule de (gnu services base) simplifient la création de ces fichiers de règle.

Procédure Scheme : udev-rule [file-name contents]

Renvoie un fichier de règle udev nommé file-name contenant les règles définie par le littéral contents.

Dans l’exemple suivant, on définie une règle pour un périphérique USB qui sera stockée dans le fichier 90-usb-thing.rules. La règle lance un script à la détection du périphérique USB avec l’identifiant de produit donné.

(define %example-udev-rule
  (udev-rule
    "90-usb-thing.rules"
    (string-append "ACTION==\"add\", SUBSYSTEM==\"usb\", "
                   "ATTR{product}==\"Example\", "
                   "RUN+=\"/path/to/script\"")))

La commande herd rules udev, en tant que root, renvoie le nom du répertoire contenant toutes les règles udev actives.

Ici on montre comment le service udev-service par défaut peut être étendu avec cette règle.

(operating-system
 ;; …
 (services
 (modify-services %desktop-services
   (udev-service-type config =>
     (udev-configuration (inherit config)
      (rules (append (udev-configuration-rules config)
                     (list %example-udev-rule))))))))
Procédure Scheme : file->udev-rule [file-name file]

Renvoie un fichier udev nommé file-name contenant les règles définies dans file, un objet simili-fichier.

L’exemple suivant montre comment utiliser un fichier de règles existant.

(use-modules (guix download)     ;for url-fetch
             (guix packages)     ;for origin
             …)

(define %android-udev-rules
  (file->udev-rule
    "51-android-udev.rules"
    (let ((version "20170910"))
      (origin
       (method url-fetch)
       (uri (string-append "https://raw.githubusercontent.com/M0Rf30/"
                           "android-udev-rules/" version "/51-android.rules"))
       (sha256
        (base32 "0lmmagpyb6xsq6zcr2w1cyx9qmjqmajkvrdbhjx32gqf1d9is003"))))))

En plus, les définitions des paquets de Guix peuvent être inclus dans rules pour étendre les règles avec les définitions trouvées dans leur sous-répertoire lib/udev/rules.d. Au lieu de l’exemple file->udev-rule précédent, on aurait pu utiliser le paquet android-udev-rules qui existe dans le module (gnu packages android).

L’exemple suivant montre comment utiliser le paquet android-udev-rules pour que l’outil Android adb puisse détecter les appareils sans privilège root. Il détaille aussi comment créer le groupe adbusers, requis pour le bon fonctionnement des règles définies dans le paquet android-udev-rules. Pour créer ce groupe, on doit le définir dans les supplementary-groups de la déclaration user-account ainsi que dans le champ groups de l’enregistrement operating-system.

(use-modules (gnu packages android)  ;for android-udev-rules
             (gnu system shadow)     ;for user-group
             …)

(operating-system
  ;; …
  (users (cons (user-account
                ;; …
                (supplementary-groups
                 '("adbusers"   ;for adb
                   "wheel" "netdev" "audio" "video")))))

  (groups (cons (user-group (system? #t) (name "adbusers"))
                %base-groups))

  ;; …

  (services
   (modify-services %desktop-services
     (udev-service-type
      config =>
      (udev-configuration (inherit config)
                          (rules (cons android-udev-rules
                                       (udev-configuration-rules config))))))))
Variable Scheme : urandom-seed-service-type

Garde de l’entropie dans %random-seed-file pour démarrer /dev/urandom au redémarrage. Ce service essaye aussi de démarrer /dev/urandom à partir de /dev/hwrng au démarrage si /dev/hwrng existe et peut être lu.

Variable Scheme : %random-seed-file

C’est le nom du fichier où des octets aléatoires sont sauvegardés par urandom-seed-service pour démarrer /dev/urandom au redémarrage. Sa valeur par défaut est /var/lib/random-seed.

Variable Scheme : gpm-service-type

C’est le type du service qui lance GPM, le démon de souris à but général, qui fournit le support de la souris sur la console Linux. GPM permet aux utilisateurs d’utiliser la souris dans la console, entre autres pour sélectionner, copier et coller du texte.

The value for services of this type must be a gpm-configuration (see below). This service is not part of %base-services.

Type de données : gpm-configuration

Type de données représentant la configuration de GPM.

options (par défaut : %default-gpm-options)

Les options de la ligne de commande à passer à gpm. L’ensemble des options par défaut dit à gpm d’écouter les événements de la souris dans /dev/input/mice. Voir Command Line dans gpm manual, pour plus d’informations.

gpm (par défaut : gpm)

Le paquet GPM à utiliser.

Variable Scheme : guix-publish-service-type

This is the service type for guix publish (voir Invoquer guix publish). Its value must be a guix-publish-configuration object, as described below.

Ce service suppose que /etc/guix contient déjà une paire de clefs créée par guix archive --generate-key (voir Invoquer guix archive). Si ce n’est pas le cas, le service ne démarrera pas.

Type de données : guix-publish-configuration

Le type de données représentant la configuration du service guix publish.

guix (par défaut : guix)

Le paquet Guix à utiliser.

port (par défaut : 80)

Le port TCP sur lequel écouter les connexions.

host (par défaut : "localhost")

L’hôte (et donc, l’interface réseau) sur lequel écouter. Utilisez "0.0.0.0" pour écouter sur toutes les interfaces réseaux.

compression (default: '(("gzip" 3)))

This is a list of compression method/level tuple used when compressing substitutes. For example, to compress all substitutes with both lzip at level 7 and gzip at level 9, write:

'(("lzip" 7) ("gzip" 9))

Level 9 achieves the best compression ratio at the expense of increased CPU usage, whereas level 1 achieves fast compression.

An empty list disables compression altogether.

nar-path (par défaut : "nar")

Le chemin d’URL où les « nars » se trouvent. Voir --nar-path, pour des détails.

cache (par défaut : #f)

Lorsque la valeur est #f, désactive le cache et génère les archives à la demande. Sinon, cela devrait être le nom d’un répertoire — p. ex. "/var/cache/guix/publish" — où guix publish gère le cache des archives et des métadonnées prêtes à être envoyées. Voir --cache, pour plus d’informations sur les compromis impliqués.

workers (par défaut : #f)

Lorsque la valeur est un entier, c’est le nombre de threads de travail utilisés pour le cache ; lorsque la valeur est #f, le nombre de processeurs est utilisé. Voir --workers, pour plus d’informations.

ttl (par défaut : #f)

Lorsque la valeur est un entier, il dénote la durée de vie en secondes des archives publiées. Voir --ttl, pour plus d’informations.

Procédure Scheme : rngd-service [#:rng-tools rng-tools] [#:device "/dev/hwrng"]

Renvoie un service qui lance le programme rngd de rng-tools pour ajouter device à la réserve d’entropie du noyau. Le service échouera si device n’existe pas.

Procédure Scheme : pam-limits-service [#:limits '()]

Renvoie un service qui installe un fichier de configuration pour le module pam_limits. La procédure prend éventuellement une liste de valeurs pam-limits-entry qui peuvent être utilisées pour spécifier les limites ulimit et les priorités des sessions utilisateurs.

La définition de limites suivante défini deux limites matérielles et logicielles pour toutes les sessions connectées des utilisateurs du groupe realtime :

(pam-limits-service
 (list
  (pam-limits-entry "@realtime" 'both 'rtprio 99)
  (pam-limits-entry "@realtime" 'both 'memlock 'unlimited)))

La première entrée augment la priorité en temps réel maximale des processus non privilégiés ; la deuxième entrée abandonne les restrictions sur l’espace d’adressage maximal qui peut être verrouillé en mémoire. Ces paramètres sont souvent utilisés sur les systèmes audio temps-réel.


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

8.8.2 Exécution de tâches planifiées

Le module (gnu services mcron) fournit une interface pour GNU mcron, un démon qui lance des tâches planifiées (voir GNU mcron). GNU mcron est similaire au démon Unix traditionnel cron ; la principale différence est qu’il est implémenté en Guile Scheme, qui fournit beaucoup de flexibilité lors de la spécification de la planification des tâches et de leurs actions.

L’exemple en dessous définit un système d’exploitation qui lance les commandes updatebd (voir Invoking updatedb dans Finding Files) et guix gc (voir Invoquer guix gc) tous les jours, ainsi que la commande mkid en tant qu’utilisateur non privilégié (voir mkid invocation dans ID Database Utilities). Il utilise des gexps pour introduire des définitions de tâches qui sont passées à mcron (voir G-Expressions).

(use-modules (guix) (gnu) (gnu services mcron))
(use-package-modules base idutils)

(define updatedb-job
  ;; Lance « updatedb » à 3h du matin chaque jour.  Ici nous spécifions
  ;; l'action de la tâche comme une procédure Scheme.
  #~(job '(next-hour '(3))
         (lambda ()
           (execl (string-append #$findutils "/bin/updatedb")
                  "updatedb"
                  "--prunepaths=/tmp /var/tmp /gnu/store"))))

(define garbage-collector-job
  ;; Lance le ramasse-miettes tous les jours à minuit cinq.
  ;; L'action de la tâche est une commande shell.
  #~(job "5 0 * * *"            ;Vixie cron syntax
         "guix gc -F 1G"))

(define idutils-job
  ;; Met à jour la base de données d'index en tant que « charlie » à 12h15
  ;; et 19h15.  La commande est lancée depuis le répertoire personnel de l'utilisateur.
  #~(job '(next-minute-from (next-hour '(12 19)) '(15))
         (string-append #$idutils "/bin/mkid src")
         #:user "charlie"))

(operating-system
  ;; …
  (services (cons (service mcron-service-type
                           (mcron-configuration
                            (jobs (list garbage-collector-job
                                        updatedb-job
                                        idutils-job))))
                  %base-services)))

For more complex jobs defined in Scheme where you need control over the top level, for instance to introduce a use-modules form, you can move your code to a separate program using the program-file procedure of the (guix gexp) module (voir G-Expressions). The example below illustrates that.

(define %battery-alert-job
  ;; Beep when the battery percentage falls below %MIN-LEVEL.
  #~(job
     '(next-minute (range 0 60 1))
     #$(program-file
        "battery-alert.scm"
        (with-imported-modules (source-module-closure
                                '((guix build utils)))
          #~(begin
              (define %min-level 20)
              (use-modules (guix build utils)
                           (ice-9 popen)
                           (ice-9 regex)
                           (ice-9 textual-ports)
                           (srfi srfi-2))
              (setenv "LC_ALL" "C")     ;ensure English output
              (and-let* ((input-pipe (open-pipe*
                                      OPEN_READ
                                      #$(file-append acpi "/bin/acpi")))
                         (output (get-string-all input-pipe))
                         (m (string-match "Discharging, ([0-9]+)%" output))
                         (level (string->number (match:substring m 1)))
                         ((< level %min-level)))
                (format #t "warning: Battery level is low (~a%)~%" level)
                (invoke #$(file-append beep "/bin/beep") "-r5")))))))

Voir mcron job specifications dans GNU mcron, pour plus d’informations sur les spécifications des tâche de mcron. Ci-dessous est la référence du service mcron.

Sur un système lancé, vous pouvez utiliser l’action schedule du service pour visualiser les travaux mcron qui seront exécutés ensuite :

# herd schedule mcron

Cet exemple ci-dessus montre les cinq tâches qui seront exécutés, mais vous pouvez spécifier le nombre de tâches à afficher :

# herd schedule mcron 10
Variable Scheme : mcron-service-type

C’est le type du service mcron, dont la valeur est un objet mcron-configuration

Ce type de service peut être la cible d’une extension de service qui lui fournit des spécifications de tâches supplémentaires (voir Composition de services). En d’autres termes, il est possible de définir des services qui fournissent des tâches mcron à lancer.

Type de données : mcron-configuration

Type données qui représente la configuration de mcron.

mcron (par défaut : mcron)

Le paquet mcron à utiliser.

jobs

C’est la liste des gexps (voir G-Expressions), où chaque gexp correspond à une spécification de tâche de mcron (voir mcron job specifications dans GNU mcron).


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

8.8.3 Rotation des journaux

Les fichiers journaux comme ceux qui se trouvent dans /var/log ont tendance à grandir sans fin, donc c’est une bonne idée de le faire tourner de temps à autres — c.-à-d. archiver leur contenu dans des fichiers séparés, potentiellement compressés. Le module (gnu services admin) fournit une interface pour GNU Rot[t]log, un outil de rotation de journaux (voir GNU Rot[t]log Manual).

This service is part of %base-services, and thus enabled by default, with the default settings, for commonly encountered log files. The example below shows how to extend it with an additional rotation, should you need to do that (usually, services that produce log files already take care of that):

(use-modules (guix) (gnu))
(use-service-modules admin)

(define my-log-files
  ;; Log files that I want to rotate.
  '("/var/log/something.log" "/var/log/another.log"))

(operating-system
  ;; …
  (services (cons (simple-service 'rotate-my-stuff
                                  rottlog-service-type
                                  (list (log-rotation
                                         (frequency 'daily)
                                         (files my-log-files))))
                  %base-services)))
Variable Scheme : rottlog-service-type

C’est le type du service Rotlog, dont la valeur est un objet rottlog-configuration.

D’autres services peuvent étendre celui-ci avec de nouveaux objets log-rotation (voir plus bas), en augmentant ainsi l’ensemble des fichiers à faire tourner.

Ce type de service peut définir des taches (voir Exécution de tâches planifiées) pour lancer le service rottlog.

Type de données : rottlog-configuration

Type de données représentant la configuration de rottlog.

rottlog (par défaut : rottlog)

Le paquet Rottlog à utiliser.

rc-file (par défaut : (file-append rottlog "/etc/rc"))

Le fichier de configuration Rottlog à utiliser (voir Mandatory RC Variables dans GNU Rot[t]log Manual).

rotations (par défaut : %default-rotations)

Une liste d’objets log-rotation définis plus bas.

jobs

C’est une liste de gexps où chaque gexp correspond à une spécification de tache de mcron (voir Exécution de tâches planifiées).

Type de données : log-rotation

Type de données représentant la rotation d’un groupe de fichiers journaux.

En reprenant un exemple du manuel de Rottlog (voir Period Related File Examples dans GNU Rot[t]log Manual), on peut définir la rotation d’un journal de cette manière :

(log-rotation
  (frequency 'daily)
  (files '("/var/log/apache/*"))
  (options '("storedir apache-archives"
             "rotate 6"
             "notifempty"
             "nocompress")))

La liste des champs est la suivante :

frequency (par défaut : 'weekly)

La fréquence de rotation, un symbole.

files

La liste des fichiers ou des motifs de noms de fichiers à faire tourner.

options (par défaut : '())

La liste des options de rottlog pour cette rotation (voir Configuration parameters dans GNU Rot[t]lg Manual).

post-rotate (par défaut : #f)

Soit #f, soit une gexp à exécuter une fois la rotation terminée.

Variable Scheme : %default-rotations

Specifies weekly rotation of %rotated-files and of /var/log/guix-daemon.log.

Variable Scheme : %rotated-files

The list of syslog-controlled files to be rotated. By default it is: '("/var/log/messages" "/var/log/secure" "/var/log/debug" \ "/var/log/maillog").


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

8.8.4 Services réseau

Le module (gnu services networking) fournit des services pour configurer les interfaces réseaux.

Variable Scheme : dhcp-client-service-type

C’est le type de services qui lance dhcp, un client DHC (protocole de configuration d’hôte dynamique) sur toutes les interfaces réseau non-loopback. Sa valeur est le paquet du client DHCP à utiliser, isc-dhcp par défaut.

Procédure Scheme : dhcpd-service-type

Ce type définie un service qui lance un démon DHCP. Pour créer un service de ce type, vous devez appliquer un objet <dhcpd-configuration>. Par exemple :

(service dhcpd-service-type
         (dhcpd-configuration
          (config-file (local-file "my-dhcpd.conf"))
          (interfaces '("enp0s25"))))
Type de données : dhcpd-configuration
package (par défaut : isc-dhcp)

Le paquet qui fournit le démon DHCP. ce paquet doit fournir le démon sbin/dhcpd relativement à son répertoire de sortie. Le paquet par défaut est le serveur DHCP d’ISC

config-file (par défaut : #f)

Le fichier de configuration à utiliser. Il est requis. Il sera passé à dhcpd via son option -cf. La valeur peut être n’importe quel objet « simili-fichier » (voir file-like objects). Voir man dhcpd.conf pour des détails sur la syntaxe du fichier de configuration.

version (par défaut : "4")

La version de DHCP à utiliser. Le serveur DHCP d’ISC supporte les valeur « 4 », « 6 » et « 4o6 ». Elles correspondent aux options -4, -6 et -4o6 du programme dhcpd. Voir man dhcpd pour plus de détails.

run-directory (par défaut : "/run/dhcpd")

Le répertoire d’exécution à utiliser. Au moment de l’activation du service, ce répertoire sera créé s’il n’existe pas.

pid-file (par défaut : "/run/dhcpd/dhcpd.pid")

Le fichier de PID à utiliser. Cela correspond à l’option -pf de dhcpd. Voir man dhcpd pour plus de détails.

interfaces (par défaut : '())

Les noms des interfaces réseaux sur lesquelles dhcpd écoute. Si cette liste n’est pas vide, alors ses éléments (qui doivent être des chaînes de caractères) seront ajoutés à l’invocation de dhcpd lors du démarrage du démon. Il n’est pas forcément nécessaire de spécifier des interfaces ici ; voir man dhcpd pour plus de détails.

Variable Scheme : static-networking-service-type

C’est le type des interfaces réseaux configurés statiquement.

Procédure Scheme : static-networking-service interface ip [#:netmask #f] [#:gateway #f] [#:name-servers '()] [#:requirement '(udev)]

Renvoie un service qui démarre interface avec l’adresse ip. Si netmask est vrai, il sera utilisé comme masque de sous-réseau. Si gateway est vrai, ce doit être une chaîne de caractères qui spécifie la passerelle par défaut du réseau. requirement peut être utilisé pour déclarer une dépendance sur un autre service avant de configurer l’interface.

On peut appeler cette procédure plusieurs fois, une fois par interface réseau qui nous intéresse. Dans les coulisses, elle étend static-networking-service-type avec les interfaces réseaux supplémentaires à gérer.

Par exemple :

(static-networking-service "eno1" "192.168.1.82"
                           #:gateway "192.168.1.2"
                           #:name-servers '("192.168.1.2"))
Procédure Scheme : wicd-service [#:wicd wicd]

Renvoie un service qui lance Wicd, un démon de gestion réseau qui cherche à simplifier la configuration des réseaux filaires et sans fil.

Ce service ajoute le paquet wicd au profil global, pour fournir des commandes pour interagir avec le démon et configurer le réseau : wicd-client, une interface graphique et les interfaces utilisateurs wicd-cli et wicd-curses.

Variable Scheme : modem-manager-service-type

C’est le type de service pour le service ModemManager. La valeur de ce type de service est un enregistrement modem-manager-configuration.

Ce service fait partie de %desktop-services (voir Services de bureaux).

Type de données : modem-manager-configuration

Type de donnée représentant la configuration de ModemManager.

modem-manager (par défaut : modem-manager)

Le paquet ModemManager à utiliser.

Scheme Variable : usb-modeswitch-service-type

This is the service type for the USB_ModeSwitch service. The value for this service type is a usb-modeswitch-configuration record.

When plugged in, some USB modems (and other USB devices) initially present themselves as a read-only storage medium and not as a modem. They need to be modeswitched before they are usable. The USB_ModeSwitch service type installs udev rules to automatically modeswitch these devices when they are plugged in.

Ce service fait partie de %desktop-services (voir Services de bureaux).

Data Type : usb-modeswitch-configuration

Data type representing the configuration of USB_ModeSwitch.

usb-modeswitch (default: usb-modeswitch)

The USB_ModeSwitch package providing the binaries for modeswitching.

usb-modeswitch-data (default: usb-modeswitch-data)

The package providing the device data and udev rules file used by USB_ModeSwitch.

config-file (default: #~(string-append #$usb-modeswitch:dispatcher "/etc/usb_modeswitch.conf"))

Which config file to use for the USB_ModeSwitch dispatcher. By default the config file shipped with USB_ModeSwitch is used which disables logging to /var/log among other default settings. If set to #f, no config file is used.

Variable Scheme : network-manager-service-type

C’est le type de service pour le service NetworkManager. La valeur pour ce type de service est un enregistrement network-manager-configuration.

Ce service fait partie de %desktop-services (voir Services de bureaux).

Type de données : network-manager-configuration

Type de données représentant la configuration de NetworkManager.

network-manager (par défaut : network-manager)

Le paquet NetworkManager à utiliser.

dns (par défaut : "default")

Mode de gestion pour le DNS, qui affecte la manière dont NetworkManager utilise le fichier de configuration resolv.conf

default

NetworkManager mettra à jour resolv.conf pour refléter les serveurs de noms fournis par les connexions actives.

dnsmasq

NetworkManager will run dnsmasq as a local caching nameserver, using a conditional forwarding configuration if you are connected to a VPN, and then update resolv.conf to point to the local nameserver.

With this setting, you can share your network connection. For example when you want to share your network connection to another laptop via an Ethernet cable, you can open nm-connection-editor and configure the Wired connection’s method for IPv4 and IPv6 to be “Shared to other computers” and reestablish the connection (or reboot).

You can also set up a host-to-guest connection to QEMU VMs (voir Installer Guix dans une VM). With a host-to-guest connection, you can e.g. access a Web server running on the VM (voir Services web) from a Web browser on your host system, or connect to the VM via SSH (voir openssh-service-type). To set up a host-to-guest connection, run this command once:

nmcli connection add type tun \
 connection.interface-name tap0 \
 tun.mode tap tun.owner $(id -u) \
 ipv4.method shared \
 ipv4.addresses 172.28.112.1/24

Then each time you launch your QEMU VM (voir Lancer Guix dans une VM), pass -nic tap,ifname=tap0,script=no,downscript=no to qemu-system-....

none

NetworkManager ne modifiera pas resolv.conf.

vpn-plugins (par défaut : '())

C’est la liste des greffons disponibles pour les VPN (réseaux privés virtuels). Un exemple est le paquet network-manager-openvpn, qui permet à NetworkManager de gérer des VPN via OpenVPN.

Variable Scheme : connman-service-type

C’est le type de service pour lancer Connman, un gestionnaire de connexions réseaux.

Sa valeur doit être un enregistrement connman-configuration comme dans cet exemple :

(service connman-service-type
         (connman-configuration
           (disable-vpn? #t)))

Voir plus bas pour des détails sur connman-configuration.

Type de données : connman-configuration

Type de données représentant la configuration de connman.

connman (par défaut : connman)

Le paquet connman à utiliser.

disable-vpn? (par défaut : #f)

Lorsque la valeur est vraie, désactive le greffon vpn de connman.

Variable Scheme : wpa-supplicant-service-type

C’est le type du service qui lanceWPA supplicant, un démon d’authentification requis pour s’authentifier sur des WiFi chiffrés ou des réseaux ethernet.

Type de données : wpa-supplicant-configuration

Type données qui représente la configuration de WPA Supplicant.

Il prend les paramètres suivants :

wpa-supplicant (par défaut : wpa-supplicant)

Le paquet WPA Supplicant à utiliser.

dbus? (par défaut : #t)

Indique s’il faut écouter les requêtes sur D-Bus.

pid-file (par défaut : "/var/run/wpa_supplicant.pid")

Où stocker votre fichier de PID.

interface (par défaut : #f)

Si une valeur est indiquée, elle doit spécifier le nom d’une interface réseau que WPA supplicant contrôlera.

config-file (par défaut : #f)

Fichier de configuration facultatif à utiliser.

extra-options (par défaut : '())

Liste d’arguments de la ligne de commande supplémentaires à passer au démon.

Variable Scheme : iptables-service-type

C’est le type de service pour mettre en place une configuration iptables. iptables est un outil de filtrage de paquets pris en charge par le noyau Linux. Ce service prend en charge la configuration d’iptable pour IPv4 et IPv6. Un exemple de configuration simple, qui rejette les connexions entrantes sauf celles sur le port 22 est présenté ci-dessous.

(service iptables-service-type
         (iptables-configuration
          (ipv4-rules (plain-file "iptables.rules" "*filter
:INPUT ACCEPT
:FORWARD ACCEPT
:OUTPUT ACCEPT
-A INPUT -p tcp --dport 22 -j ACCEPT
-A INPUT -j REJECT --reject-with icmp-port-unreachable
COMMIT
"))
          (ipv6-rules (plain-file "ip6tables.rules" "*filter
:INPUT ACCEPT
:FORWARD ACCEPT
:OUTPUT ACCEPT
-A INPUT -p tcp --dport 22 -j ACCEPT
-A INPUT -j REJECT --reject-with icmp6-port-unreachable
COMMIT
"))))
Type de données : iptables-configuration

Type de données représentant la configuration d’iptables.

iptables (par défaut : iptables)

Le paquet iptables qui fournit iptables-restore et ip6tables-restore.

ipv4-rules (par défaut : %iptables-accept-all-rules)

Les règles iptables à utiliser. Elles seront passées à iptables-restore. Cela peut être un objet « simili-fichier » (voir file-like objects).

ipv6-rules (par défaut : %iptables-accept-all-rules)

Les règles iptables à utiliser. Elles seront passées à ip6tables-restore. Cela peut être un objet « simili-fichier » (voir file-like objects).

Scheme Variable : nftables-service-type

This is the service type to set up a nftables configuration. nftables is a netfilter project that aims to replace the existing iptables, ip6tables, arptables and ebtables framework. It provides a new packet filtering framework, a new user-space utility nft, and a compatibility layer for iptables. This service comes with a default ruleset %default-nftables-ruleset that rejecting all incomming connections except those to the ssh port 22. To use it, simply write:

(service nftables-service-type)
Data Type : nftables-configuration

The data type representing the configuration of nftables.

package (default: nftables)

The nftables package that provides nft.

ruleset (default: %default-nftables-ruleset)

The nftables ruleset to use. This may be any “file-like” object (voir file-like objects).

Variable Scheme : ntp-service-type

This is the type of the service running the Network Time Protocol (NTP) daemon, ntpd. The daemon will keep the system clock synchronized with that of the specified NTP servers.

La valeur de ce service est un objet ntpd-configuration, décrit ci-dessous.

Type de données : ntp-configuration

C’est le type de données représentant la configuration du service NTP.

servers (par défaut : %ntp-servers)

This is the list of servers (<ntp-server> records) with which ntpd will be synchronized. See the ntp-server data type definition below.

allow-large-adjustment? (default: #t)

Détermine si ntpd peut faire un ajustement initial de plus de 1 000 secondes.

ntp (par défaut : ntp)

Le paquet NTP à utiliser.

Variable Scheme : %ntp-servers

Liste de noms d’hôtes à utiliser comme serveurs NTP par défaut. Ce sont les serveurs du projet NTP Pool

Data Type : ntp-server

The data type representing the configuration of a NTP server.

type (default: 'server)

The type of the NTP server, given as a symbol. One of 'pool, 'server, 'peer, 'broadcast or 'manycastclient.

address

The address of the server, as a string.

options

NTPD options to use with that specific server, given as a list of option names and/or of option names and values tuples. The following example define a server to use with the options iburst and prefer, as well as version 3 and a maxpoll time of 16 seconds.

(ntp-server
 (type 'server)
 (address "some.ntp.server.org")
 (options `(iburst (version 3) (maxpoll 16) prefer))))
Procédure Scheme : openntpd-service-type

Lance le démon NTP ntpd, implémenté par OpenNTPD. Le démon gardera l’horloge système synchronisée avec celle des serveurs donnés.

(service
 openntpd-service-type
 (openntpd-configuration
  (listen-on '("127.0.0.1" "::1"))
  (sensor '("udcf0 correction 70000"))
  (constraint-from '("www.gnu.org"))
  (constraints-from '("https://www.google.com/"))
  (allow-large-adjustment? #t)))

Scheme Variable : %openntpd-servers

This variable is a list of the server addresses defined in %ntp-servers.

Type de données : openntpd-configuration
openntpd (par défaut : (file-append openntpd "/sbin/ntpd"))

L’exécutable openntpd à utiliser.

listen-on (par défaut : '("127.0.0.1" "::1"))

Une liste d’adresses IP locales ou de noms d’hôtes que devrait écouter le démon ntpd.

query-from (par défaut : '())

Une liste d’adresses IP que le démon devrait utiliser pour les requêtes sortantes.

sensor (par défaut : '())

Spécifie une liste de senseurs de différences de temps que ntpd devrait utiliser. ntpd écoutera chaque senseur qui existe et ignorera ceux qui n’existent pas. Voir la documentation en amont pour plus d’informations.

server (default: '())

Spécifie une liste d’adresses IP ou de noms d’hôtes de serveurs NTP avec lesquels se synchroniser.

servers (default: %openntp-servers)

Spécifie une liste d’adresses IP ou de noms d’hôtes de banques de serveurs NTP avec lesquelles se synchroniser.

constraint-from (par défaut : '())

ntpd peut être configuré pour demander la « Date » à des serveurs HTTPS de confiance via TLS. Cette information de temps n’est pas utilisée pour sa précision mais agit comme une contrainte authentifiée, ce qui réduit l’impact d’une attaque par l’homme du milieu sur le protocole NTP non authentifié. Spécifie une liste d’URL, d’adresses IP ou de noms d’hôtes de serveurs HTTPS qui fournissent cette contrainte.

constraints-from (par défaut : '())

Comme pour constraint-from, spécifie une liste d’URL, d’adresses IP ou de noms d’hôtes de serveurs HTTPS qui fournissent une contrainte. Si les noms d’hôtes sont résolus en plusieurs adresses IP, ntpd calculera la contrainte médiane.

allow-large-adjustment? (par défaut : #f)

Détermine si ntpd peut faire un ajustement initial de plus de 180 secondes.

Variable Scheme : inetd-service-type

Ce service lance le démon inetd (voir inetd invocation dans GNU Inetutils). inetd écoute des connexions sur des sockets internet et démarre le programme spécifié uniquement lorsqu’une connexion arrive sur l’un de ces sockets.

La valeur de ce service est un objet inetd-configuration. L’exemple suivant configure le démon inetd pour qu’il fournisse le service echo, ainsi qu’un service smtp qui transfère le trafic smtp par ssh à un serveur smtp-server derrière une passerelle hostname :

(service
 inetd-service-type
 (inetd-configuration
  (entries (list
            (inetd-entry
             (name "echo")
             (socket-type 'stream)
             (protocol "tcp")
             (wait? #f)
             (user "root"))
            (inetd-entry
             (node "127.0.0.1")
             (name "smtp")
             (socket-type 'stream)
             (protocol "tcp")
             (wait? #f)
             (user "root")
             (program (file-append openssh "/bin/ssh"))
             (arguments
              '("ssh" "-qT" "-i" "/path/to/ssh_key"
                "-W" "smtp-server:25" "user@hostname")))))))

Voir plus bas pour plus de détails sur inetd-configuration.

Type de données : inetd-configuration

Type de données représentant la configuration de inetd.

program (par défaut : (file-append inetutils "/libexec/inetd"))

L’exécutable inetd à utiliser.

entries (par défaut : '())

Une liste d’entrées de services inetd. Chaque entrée devrait être crée avec le constructeur inetd-entry.

Type de données : inetd-entry

Type de données représentant une entrée dans la configuration d’inetd. Chaque entrée correspond à un socket sur lequel inetd écoutera les requêtes.

node (par défaut : #f)

Chaîne de caractères facultative, un liste d’adresses locales séparées par des virgules que inetd devrait utiliser pour écouter ce service. Voir Configuration file dans GNU Inetutils pour une description complète de toutes les options.

name

Une chaîne de caractères dont le nom doit correspondre à une entrée de /etc/services.

socket-type

Un symbole parmi 'stream, 'dgram, 'raw, 'rdm ou 'seqpacket.

protocol

Une chaîne de caractères qui doit correspondre à une entrée dans /etc/protocols.

wait? (par défaut : #t)

Indique si inetd devrait attendre que le serveur ait quitté avant d’écouter de nouvelles demandes de service.

user

Une chaîne de caractères contenant le nom d’utilisateur (et éventuellement de groupe) de l’utilisateur en tant que lequel le serveur devrait tourner. Le nom du groupe peut être spécifié comme un suffixe, séparé par un deux-points ou un point, c.-à-d. "utilisateur", "utilisateur:groupe" ou "utilisateur.groupe".

program (par défaut : "internal")

Le programme du serveur qui servira les requêtes, ou "internal" si inetd devrait utiliser un service inclus.

arguments (par défaut : '())

Une liste de chaînes de caractères ou d’objets simili-fichiers qui sont les arguments du programme du serveur, en commençant par le zéroième argument, c.-à-d. le nom du programme lui-même. Pour les services internes à inetd, cette entrée doit être '() ou '("internal").

Voir Configuration file dans GNU Inetutils pour trouver une discussion plus détaillée de chaque champ de configuration.

Variable Scheme : tor-service-type

C’est le type pour un service qui lance le démon de navigation anonyme Tor. Le service est configuré avec un enregistrement <tor-configuration>. Par défaut, le démon Tor est lancé en tant qu’utilisateur non privilégié tor, membre du groupe tor.

Type de données : tor-configuration
tor (par défaut : tor)

Le paquet qui fournit le démon Tor. Ce paquet doit fournir le démon bin/tor relativement à son répertoire de sortie. Le paquet par défaut est le l’implémentation du projet Tor.

config-file (par défaut : (plain-file "empty" ""))

Le fichier de configuration à utiliser. Il sera ajouté au fichier de configuration par défaut, et le fichier de configuration final sera passé à tor via son option -f. Cela peut être n’importe quel objet « simili-fichier » (voir file-like objects). Voir man tor pour plus de détails sur la syntaxe du fichier de configuration.

hidden-services (par défaut : '())

La liste des enregistrements <hidden-service> à utiliser. Pour n’importe quel service cache que vous ajoutez à cette liste, la configuration appropriée pour activer le service caché sera automatiquement ajouté au fichier de configuration par défaut. Vous pouvez aussi créer des enregistrements <hidden-service> avec la procédure tor-hidden-service décrite plus bas.

socks-socket-type (par défaut : 'tcp)

Le type de socket par défaut que Tor devrait utiliser pour les socket SOCKS. Cela doit être soit 'tcp soit 'unix. S’il s’agit de 'tcp, alors Tor écoutera pas défaut sur le port TCP 9050 sur l’interface de boucle locale (c.-à-d. localhost). S’il s’agit de 'unix, Tor écoutera sur le socket UNIX domain /var/run/tor/socks-sock, qui sera inscriptible pour les membres du groupe tor.

Si vous voulez personnaliser le socket SOCKS plus avant, laissez socks-socket-type à sa valeur par défaut de 'tcp et utilisez config-file pour remplacer les valeurs par défaut avec votre propre option SocksPort.

Procédure Scheme : tor-hidden-service name mapping

Définie un service caché pour Tor nommé name qui implémente mapping. mapping est une liste de paires de port et d’hôte, comme dans :

 '((22 "127.0.0.1:22")
   (80 "127.0.0.1:8080"))

Dans cet exemple, le port 22 du service caché est relié au port local 22 et le port 80 est relié au port local 8080.

Cela crée un répertoire /var/lib/tor/hidden-services/name où le fichier hostname contient le nom d’hôte .onion pour le service caché.

Voir the Tor project’s documentation pour trouver plus d’information.

Le module (gnu services rsync) fournit les services suivant :

Vous pourriez vouloir un démon rsync si vous voulez que des fichiers soient disponibles pour que n’importe qui (ou juste vous) puisse télécharger des fichiers existants ou en téléverser des nouveaux.

Variable Scheme : rsync-service-type

C’est le type pour le démon rsync. La valeur de ce service est un enregistrement rsync-configuration comme dans cet exemple :

(service rsync-service-type)

Voir plus pas pour trouver des détails à propos de rsync-configuration.

Type de données : rsync-configuration

Type de données représentant la configuration de rsync-service.

package (par défaut : rsync)

Le paquet rsync à utiliser.

port-number (par défaut : 873)

Le port TCP sur lequel rsync écoute les connexions entrantes. Si le port est inférieur à 1024, rsync doit être démarré en tant qu’utilisateur et groupe root.

pid-file (par défaut : "/var/run/rsyncd/rsyncd.pid")

Nom du fichier où rsync écrit son PID.

lock-file (par défaut : "/var/run/rsyncd/rsyncd.lock")

Nom du fichier où rsync écrit son fichier de verrouillage.

log-file (par défaut : "/var/log/rsyncd.log")

Nom du fichier où rsync écrit son fichier de journal.

use-chroot? (par défaut : #t)

S’il faut utiliser un chroot pour le répertoire partagé de rsync.

share-path (par défaut : /srv/rsync)

Emplacement du répertoire partagé de rsync.

share-comment (par défaut : "Rsync share")

Commentaire du répertoire partagé de rsync.

read-only? (par défaut : #f)

Permission en écriture sur le répertoire partagé.

timeout (par défaut : 300)

Délai d’attente d’entrée-sortie en secondes.

user (par défaut : "root")

Propriétaire du processus rsync.

group (par défaut : "root")

Groupe du processus rsync.

uid (par défaut : "rsyncd")

Nom d’utilisateur ou ID utilisateur en tant que lequel les transferts de fichiers ont lieu si le démon a été lancé en root.

gid (par défaut : "rsyncd")

Nom du groupe ou ID du groupe qui sera utilisé lors de l’accès au module.

En plus, (gnu services ssh) fournit les services suivant.

Procédure Scheme : lsh-service [#:host-key "/etc/lsh/host-key"] [#:daemonic? #t] [#:interfaces '()] [#:port-number 22] [#:allow-empty-passwords? #f] [#:root-login? #f] [#:syslog-output? #t] [#:x11-forwarding? #t] [#:tcp/ip-forwarding? #t] [#:password-authentication? #t] [#:public-key-authentication? #t] [#:initialize? #t]

Lance le programme lshd de lsh pour écouter sur le port port-number. host-key doit désigner un fichier contenant la clef d’hôte et ne doit être lisible que par root.

Lorsque daemonic? est vrai, lshd se détachera du terminal qui le contrôle et enregistrera ses journaux avec syslogd, à moins que syslog-output? ne soit faux. Évidemment, cela rend aussi lsh-service dépendant de l’existence d’un service syslogd. Lorsque pid-file? est vrai, lshd écrit son PID dans le fichier pid-file.

Lorsque initialize? est vrai, la graine et la clef d’hôte seront créés lors de l’activation du service s’ils n’existent pas encore. Cela peut prendre du temps et demande une interaction.

Lorsque initialize? est faux, c’est à l’utilisateur d’initialiser le générateur d’aléatoire (voir lsh-make-seed dans LSH Manual) et de crée une paire de clefs dont la clef privée sera stockée dans le fichier host-key (voir lshd basics dans LSH Manual).

Lorsque interfaces est vide, lshd écoute les connexions sur toutes les interfaces réseau ; autrement, interfaces doit être une liste de noms d’hôtes et d’adresses.

allow-empty-passwords? spécifie si les connexions avec des mots de passes vides sont acceptés et root-login? spécifie si la connexion en root est acceptée.

Les autres options devraient être évidentes.

Variable Scheme : openssh-service-type

C’est le type pour le démon ssh OpenSSH, sshd. Sa valeur doit être un enregistrement openssh-configuration comme dans cet exemple :

(service openssh-service-type
         (openssh-configuration
           (x11-forwarding? #t)
           (permit-root-login 'without-password)
           (authorized-keys
             `(("alice" ,(local-file "alice.pub"))
               ("bob" ,(local-file "bob.pub"))))))

Voir plus bas pour trouver des détails sur openssh-configuration.

Ce service peut être étendu avec des clefs autorisées supplémentaires, comme dans cet exemple :

(service-extension openssh-service-type
                   (const `(("charlie"
                             ,(local-file "charlie.pub")))))
Type de données : openssh-configuration

C’est l’enregistrement de la configuration de la commande sshd d’OpenSSH.

pid-file (par défaut : "/var/run/sshd.pid")

Nom du fichier où sshd écrit son PID.

port-number (par défaut : 22)

Port TCP sur lequel sshd écoute les connexions entrantes.

permit-root-login (par défaut : #f)

Ce champ détermine si et quand autoriser les connexions en root. Si la valeur est #f, les connexions en root sont désactivées ; si la valeur est #t, elles sont autorisées. S’il s’agit du symbole 'without-password, alors les connexions root sont autorisées mais pas par une authentification par mot de passe.

allow-empty-passwords? (par défaut : #f)

Lorsque la valeur est vraie, les utilisateurs avec un mot de passe vide peuvent se connecter. Sinon, ils ne peuvent pas.

password-authentication? (par défaut : #t)

Lorsque la valeur est vraie, les utilisateurs peuvent se connecter avec leur mot de passe. Sinon, ils doivent utiliser une autre méthode d’authentification.

public-key-authentication? (par défaut : #t)

Lorsque la valeur est vraie, les utilisateurs peuvent se connecter avec leur clef publique. Sinon, les utilisateurs doivent utiliser une autre méthode d’authentification.

Les clefs publiques autorisées sont stockées dans ~/.ssh/authorized_keys. Ce n’est utilisé que par le protocole version 2.

x11-forwarding? (par défaut : #f)

Lorsque la valeur est vraie, le transfert de connexion du client graphique X11 est activé — en d’autre termes, les options -X et -Y de ssh fonctionneront.

allow-agent-forwarding? (par défaut : #t)

Indique s’il faut autoriser la redirection d’agent.

allow-tcp-forwarding? (par défaut : #t)

Indique s’il faut autoriser la redirection TCP.

gateway-ports? (par défaut : #f)

Indique s’il faut autoriser les ports de passerelle.

challenge-response-authentication? (par défaut : #f)

Spécifie si l’authentification par défi est autorisée (p. ex. via PAM).

use-pam? (par défaut : #t)

Active l’interface avec le module d’authentification greffable, PAM. Si la valeur est #t, cela activera l’authentification PAM avec challenge-response-authentication? et password-authentication?, en plus des modules de compte et de session de PAM pour tous les types d’authentification.

Comme l’authentification par défi de PAM sert généralement un rôle équivalent à l’authentification par mot de passe, vous devriez désactiver soit challenge-response-authentication?, soit password-authentication?.

print-last-log? (par défaut : #t)

Spécifie si sshd devrait afficher la date et l’heure de dernière connexion des utilisateurs lorsqu’un utilisateur se connecte de manière interactive.

subsystems (par défaut : '(("sftp" "internal-sftp")))

Configure les sous-systèmes externes (p. ex. le démon de transfert de fichiers).

C’est une liste de paires, composées chacune du nom du sous-système et d’une commande (avec éventuellement des arguments) à exécuter à la demande du sous-système.

La commande internal-sftp implémente un serveur SFTP dans le processus. Autrement, on peut spécifier la commande sftp-server :

(service openssh-service-type
         (openssh-configuration
          (subsystems
           `(("sftp" ,(file-append openssh "/libexec/sftp-server"))))))
accepted-environment (par défaut : '())

Liste de chaînes de caractères qui décrivent les variables d’environnement qui peuvent être exportées.

Chaque chaîne a sa propre ligne. Voir l’option AcceptEnv dans man sshd_config.

This example allows ssh-clients to export the COLORTERM variable. It is set by terminal emulators, which support colors. You can use it in your shell’s resource file to enable colors for the prompt and commands if this variable is set.

(service openssh-service-type
         (openssh-configuration
           (accepted-environment '("COLORTERM"))))
authorized-keys (par défaut : '())

C’est la liste des clefs autorisées. Chaque élément de la liste est un nom d’utilisateur suivit d’un ou plusieurs objets simili-fichiers qui représentent les clefs publiques SSH. Par exemple :

(openssh-configuration
  (authorized-keys
    `(("rekado" ,(local-file "rekado.pub"))
      ("chris" ,(local-file "chris.pub"))
      ("root" ,(local-file "rekado.pub") ,(local-file "chris.pub")))))

enregistre les clefs publiques spécifiées pour les comptes rekado, chris et root.

Des clefs autorisées supplémentaires peuvent être spécifiées via service-extension.

Remarquez que cela n’interfère pas avec l’utilisation de ~/.ssh/authorized_keys.

log-level (par défaut : 'info)

C’est le symbole qui spécifie le niveau de journalisation : quiet, fatal, error, info, verbose, debug, etc. Voir la page de manuel de sshd_config pour trouver la liste complète des noms de niveaux.

extra-content (par défaut : "")

Ce champ peut être utilisé pour ajouter un texte arbitraire au fichier de configuration. C’est particulièrement utile pour des configurations élaborées qui ne pourraient pas être exprimées autrement. Cette configuration, par exemple, désactiverait les connexions en root, mais les permettrait depuis une adresse IP spécifique :

(openssh-configuration
  (extra-content "\
Match Address 192.168.0.1
  PermitRootLogin yes"))
Procédure Scheme : dropbear-service [config]

Lance le démon SSH Dropbear avec la configuration config donnée, un objet <dropbear-configuration>.

Par exemple, pour spécifier un service Dropbear qui écoute sur le port 1234, ajoutez cet appel au champ services de votre système d’exploitation :

(dropbear-service (dropbear-configuration
                    (port-number 1234)))
Type de données : dropbear-configuration

Ce type de données représente la configuration d’un démon SSH Dropbear.

dropbear (par défaut : dropbear)

Le paquet Dropbear à utiliser.

port-number (par défaut : 22)

Le port TCP sur lequel le démon attend des connexions entrantes.

syslog-output? (par défaut : #t)

Indique s’il faut activer la sortie vers syslog.

pid-file (par défaut : "/var/run/dropbear.pid")

Nom du fichier de PID du démon.

root-login? (par défaut : #f)

Indique s’il faut autoriser les connexions en root.

allow-empty-passwords? (par défaut : #f)

Indique s’il faut autoriser les mots de passes vides.

password-authentication? (par défaut : #t)

Indique s’il faut autoriser l’authentification par mot de passe.

Variable Scheme : %facebook-host-aliases

Cette variable contient une chaîne de caractères à utiliser dans /etc/hosts (voir Host Names dans The GNU C Library Reference Manual). Chaque ligne contient une entrée qui fait correspondre les noms des serveurs connus du service en ligne Facebook — p. ex. www.facebook.com — à l’hôte local — 127.0.0.1 ou son équivalent en IPv6, ::1.

Cette variable est typiquement utilisée dans le champ hosts-file d’une déclaration operating-system (voir /etc/hosts) :

(use-modules (gnu) (guix))

(operating-system
  (host-name "mamachine")
  ;; ...
  (hosts-file
    ;; Crée un fichier /etc/hosts avec des alias pour « localhost »
    ;; et « mamachine », ainsi que pour les serveurs de Facebook.
    (plain-file "hosts"
                (string-append (local-host-aliases host-name)
                               %facebook-host-aliases))))

Ce mécanisme peut éviter que des programmes qui tournent localement, comme des navigateurs Web, ne se connectent à Facebook.

Le module (gnu services avahi) fourni la définition suivante.

Variable Scheme : avahi-service-type

C’est le service qui lance avahi-daemon, un service système qui répond aux requêtes mDNS/DNS-SD qui permet la découverte de service et la recherche de nom en « zéro configuration » (voir https://avahi.org/). Sa valeur doit être un enregistrement zero-configuration — voir plus bas.

This service extends the name service cache daemon (nscd) so that it can resolve .local host names using nss-mdns. Voir Name Service Switch, for information on host name resolution.

En plus, cela ajoute le paquet avahi au profil du système pour que les commandes comme avahi-browse soient directement utilisables.

Type de données : avahi-configuration

Type de données représentant la configuration d’Avahi.

host-name (par défaut : #f)

Si la valeur n’est pas #f, utilise cette valeur comme nom d’hôte à publier pour la machine ; sinon, utilise le vrai nom d’hôte de la machine.

publish? (par défaut : #t)

Lorsque la valeur est vraie, permet la publication sur le réseau (en diffusion) des noms d’hôtes et des services.

publish-workstation? (par défaut : #t)

Lorsque la valeur est vraie, avahi-daemon publie le nom d’hôte et l’adresse IP de la machine via mDNS sur le réseau local. Pour voir les noms d’hôtes publiés sur votre réseau local, vous pouvez lancer :

avahi-browse _workstation._tcp
wide-area? (par défaut : #f)

Lorsque la valeur est vraie, DNS-SD sur DNS unicast est activé.

ipv4? (par défaut : #t)
ipv6? (par défaut : #t)

Ces champs déterminent s’il faut utiliser des socket IPv4/IPv6.

domains-to-browse (par défaut : '())

C’est la liste des domaines sur lesquels naviguer.

Variable Scheme : openvswitch-service-type

C’est le type du service Open vSwitch, dont la valeur devrait être un objet openvswitch-configuration.

Type de données : openvswitch-configuration

Type de données représentant la configuration de Open vSwitch, un commutateur virtuel multiniveaux conçu pour rendre possible l’automatisation massive des réseaux avec des extensions programmables.

package (par défaut : openvswitch)

Objet de paquet de Open vSwitch.

Scheme Variable : pagekite-service-type

This is the service type for the PageKite service, a tunneling solution for making localhost servers publicly visible, even from behind restrictive firewalls or NAT without forwarded ports. The value for this service type is a pagekite-configuration record.

Here’s an example exposing the local HTTP and SSH daemons:

(service pagekite-service-type
         (pagekite-configuration
           (kites '("http:@kitename:localhost:80:@kitesecret"
                    "raw/22:@kitename:localhost:22:@kitesecret"))
           (extra-file "/etc/pagekite.rc")))
Data Type : pagekite-configuration

Data type representing the configuration of PageKite.

package (default: pagekite)

Package object of PageKite.

kitename (default: #f)

PageKite name for authenticating to the frontend server.

kitesecret (default: #f)

Shared secret for authenticating to the frontend server. You should probably put this inside extra-file instead.

frontend (default: #f)

Connect to the named PageKite frontend server instead of the pagekite.net service.

kites (default: '("http:@kitename:localhost:80:@kitesecret"))

List of service kites to use. Exposes HTTP on port 80 by default. The format is proto:kitename:host:port:secret.

extra-file (default: #f)

Extra configuration file to read, which you are expected to create manually. Use this to add additional options and manage shared secrets out-of-band.


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

8.8.5 Système de fenêtrage X

La prise en chargue du système d’affichage graphique X Window — en particulier Xorg — est fournit par le module (gnu services xorg). Remarquez qu’il n’y a pas de procédure xorg-service. À la place, le serveur X est démarré par le gestionnaire de connexion, par défaut le gestionnaire d’affichage de GNOME (GDM).

GDM permet évidemment aux utilisateurs de se connecter et d’ouvrir un gestionnaire de fenêtre ou un gestionnaire d’environnement autre que GNOME ; pour ceux qui utilisent GNOME, GDM est requis pour certaines fonctionnalités comme l’écran de verrouillage automatique.

Pour utiliser X11, vous devez installer au moins un gestionnaire de fenêtre — par exemple les paquets windowmaker ou openbox — de préférence en l’ajoutant au champ packages de votre définition de système d’exploitation (voir system-wide packages).

Variable Scheme : gdm-service-type

C’est le type pour le gestionnaire d’affichage de GNOME (GDM), un programme qui gère les serveurs d’affichage graphiques et s’occupe de la connexion graphique des utilisateurs. Sa valeur doit être un gdm-configuration (voir plus bas).

GDM cherche des types de sessions définies par les fichiers .desktop dans /run/current-system/profile/share/xsessions et permet aux utilisateurs de choisir une session depuis l’écran de connexion. Les paquets comme gnmoe, xfce et i3 fournissent des fichiers .desktop ; les ajouter à l’ensemble des paquets du système les rendra automatiquement disponibles sur l’écran de connexion.

En plus, les fichiers ~/.xsession sont honorées. Lorsqu’il est disponible, ~/.xsession doit être un fichier exécutable qui démarre un gestionnaire de fenêtre au un autre client X.

Type de données : gdm-configuration
auto-login? (par défaut : #f)
default-user (par défaut : #f)

Lorsque auto-login? est faux, GDM présente un écran de connexion.

Lorsque auto-login? est vrai, GDM se connecte directement en tant que default-user.

debug? (par défaut : #f)

When true, GDM writes debug messages to its log.

gnome-shell-assets (par défaut : …)

Liste de données requises par GDM : un thème d’icônes, des polices, etc.

xorg-configuration (par défaut : (xorg-configuration))

Configuration du serveur graphique Xorg.

xsession (par défaut : xinitrc)

Le script à lancer avant de démarrer une session X.

dbus-daemon (par défaut : dbus-daemon-wrapper)

Nom du fichier de l’exécutable dbus-daemon.

gdm (par défaut : gdm)

Le paquet GDM à utiliser.

Variable Scheme : slim-service-type

C’est de type pour le gestionnaire de connexion graphique SLiM pour X11.

Comme GDM, SLiM recherche des types de sessions décrites par des fichiers .desktop et permet aux utilisateurs de choisir une session à partir de l’écran de connexion avec F1. Il comprend aussi les fichiers ~/.xsession.

Contrairement à GDM, SLiM ne démarre pas la session utilisateur sur un terminal virtuel différent à la connexion, ce qui signifie que vous ne pouvez démarrer qu’une seule session graphique. Si vous voulez pouvoir exécuter plusieurs sessions graphiques en même temps, vous devez ajouter plusieurs services SLiM à la liste des services de votre système. L’exemple suivant montre comment remplacer le service GDM par défaut par deux services SLiM sur les tty 7 et 8.

(use-modules (gnu services)
             (gnu services desktop)
             (gnu services xorg)
             (srfi srfi-1))  ;pour « remove »

(operating-system
  ;; ...
  (services (cons* (service slim-service-type (slim-configuration
                                               (display ":0")
                                               (vt "vt7")))
                   (service slim-service-type (slim-configuration
                                               (display ":1")
                                               (vt "vt8")))
                   (remove (lambda (service)
                             (eq? (service-kind service) gdm-service-type))
                           %desktop-services))))
Type de données : slim-configuration

Type de données représentant la configuration de slim-service-type.

allow-empty-passwords? (par défaut : #t)

S’il faut autoriser les connexions avec un mot de passe vide.

auto-login? (par défaut : #f)
default-user (par défaut : "")

Lorsque auto-login? est faux, SLiM présent un écran de connexion.

Lorsque auto-login? est vrai, SLiM se connecte directement en tant que default-user.

theme (par défaut : %default-slim-theme)
theme-name (par défaut : %default-slim-theme-name)

Le thème graphique à utiliser et son nom.

auto-login-session (par défaut : #f)

Si la valeur est vraie, elle doit être le nom d’un exécutable à démarrer comme session par défaut — p. ex. (file-append windowmaker "/bin/windowmaker").

Si la valeur est fausse, une session décrite par l’un des fichiers .desktop disponibles dans /run/current-system/profile et ~/.guix-profile sera utilisée.

Remarque : Vous devez installer au moins un gestionnaire de fenêtres dans le profil du système ou dans votre profil utilisateur. Sinon, si auto-login-session est faux, vous ne serez jamais capable de vous connecter.

xorg-configuration (par défaut : (xorg-configuration))

Configuration du serveur graphique Xorg.

display (par défaut : ":0")

La session d’affichage sur laquelle démarrer le serveur graphique Xorg.

vt (par défaut : "vt7")

Le terminal virtuel sur lequel démarrer le serveur d’affichage graphique Xorg.

xauth (par défaut : xauth)

Le paquet XAuth à utiliser.

shepherd (par défaut : shepherd)

Le paquet Shepherd à utiliser pour invoquer halt et reboot.

sessreg (par défaut : sessreg)

Le paquet sessreg à utiliser pour enregistrer la session.

slim (par défaut : slim)

Le paquet SLiM à utiliser.

Variable Scheme : %default-theme
Variable Scheme : %default-theme-name

Le thème SLiM par défaut et son nom.

Type de données : sddm-configuration

C’est le type de données représentant la configuration du service sddm.

display-server (par défaut : "x11")

Choisit le serveur d’affichage à utiliser pour l’écran d’accueil. Les valeurs valides sont « x11 » et « wayland ».

numlock (par défaut : "on")

Les valeurs valides sont « on », « off » ou « none ».

halt-command (par défaut : #~(string-apppend #$shepherd "/sbin/halt"))

La commande à lancer à l’arrêt du système.

reboot-command (par défaut : #~(string-append #$shepherd "/sbin/reboot"))

La commande à lancer lors du redémarrage du système.

theme (par défaut : "maldives")

Theme to use. Default themes provided by SDDM are "elarun", "maldives" or "maya".

themes-directory (par défaut : "/run/current-system/profile/share/sddm/themes")

Le répertoire où se trouvent les thèmes.

faces-directory (par défaut : "/run/current-system/profile/share/sddm/faces")

Répertoire où se trouvent les avatars.

default-path (par défaut : "/run/current-system/profile/bin")

Le PATH par défaut à utiliser.

minimum-uid (default: 1000)

Minimum UID displayed in SDDM and allowed for log-in.

maximum-uid (default: 2000)

Maximum UID to display in SDDM.

remember-last-user? (par défaut : #t)

S’il faut se rappeler le dernier utilisateur connecté.

remember-last-session? (par défaut : #t)

S’il faut se rappeler la dernière session.

hide-users (par défaut : "")

Les noms d’utilisateurs à cacher sur l’écran d’accueil de SDDM.

hide-shells (par défaut : #~(string-append #$shadow "/sbin/nologin"))

Les utilisateurs avec les shells listés seront cachés sur l’écran d’accueil de SDDM.

session-command (par défaut : #~(string-append #$sddm "/share/sddm/scripts/wayland-session"))

Le script à lancer avant de démarrer une session wayland.

sessions-directory (par défaut : "/run/current-system/profile/share/wayland-sessions")

Le répertoire où trouver les fichiers .desktop qui démarrent des sessions wayland.

xorg-configuration (par défaut : (xorg-configuration))

Configuration du serveur graphique Xorg.

xauth-path (par défaut : #~(string-append #$xauth "/bin/xauth"))

Chemin vers xauth.

xephyr-path (par défaut : #~(string-append #$xorg-server "/bin/Xephyr"))

Chemin vers Xephyr.

xdisplay-start (par défaut : #~(string-append #$sddm "/share/sddm/scripts/Xsetup"))

Le script à lancer après avoir démarré xorg-server.

xdisplay-stop (par défaut : #~(string-append #$sddm "/share/sddm/scripts/Xstop"))

Le script à lancer avant d’arrêter xorg-server.

xsession-command (par défaut : xinitrc)

Le script à lancer avant de démarrer une session X.

xsessions-directory (par défaut : "/run/current-system/profile/share/xsessions")

Répertoire où trouver les fichiers .desktop pour les sessions X.

minimum-vt (par défaut : 7)

VT minimal à utiliser.

auto-login-user (par défaut : "")

Utilisateur à utiliser pour la connexion automatique.

auto-login-session (par défaut : "")

Le fichier desktop à utiliser pour la connexion automatique.

relogin? (par défaut : #f)

S’il faut se reconnecter après la déconnexion.

Scheme Variable : sddm-service-type

This is the type of the service to run the SDDM display manager. Its value must be a sddm-configuration record (see below).

Here’s an example use:

(service sddm-service-type
         (sddm-configuration
           (auto-login-user "alice")
           (auto-login-session "xfce.desktop")))
Type de données : sddm-configuration

This data type represents the configuration of the SDDM login manager. The available fields are:

sddm (default: sddm)

The SDDM package to use.

display-server (default: "x11")

This must be either "x11" or "wayland".

auto-login-user (default: "")

If non-empty, this is the user account under which to log in automatically.

auto-login-session (default: "")

If non-empty, this is the .desktop file name to use as the auto-login session.

Type de données : xorg-configuration

Ce type de données représente la configuration du serveur d’affichage graphique Xorg. Remarquez qu’il ne s’agit pas d’un service Xorg ; à la place, le serveur X est démarré par un « gestionnaire d’affichage graphique » comme GDM, SDDM et SLiM. Ainsi, la configuration de ces gestionnaires d’affichage agrègent un enregistrement xorg-configuration.

modules (par défaut : %default-xorg-modules)

C’est une liste de paquets de module chargés par le serveur Xorg — p. ex. xf86-video-vesa, xf86-input-keyboard etc.

fonts (par défaut : %default-xorg-fonts)

C’est une liste de répertoires de polices à ajouter au chemin de polices du serveur.

drivers (par défaut : '())

Cela doit être soit la liste vide, auquel cas Xorg choisit un pilote graphique automatiquement, soit une liste de noms de pilotes qui seront essayés dans cet ordre — p. ex. ("modesetting" "vesa")

resolutions (par défaut : '())

Lorsque resolutions est la liste vide, Xorg choisit une résolution d’écran appropriée. Sinon, il doit s’agir d’une liste de résolutions — p. ex. ((1024 768) (640 480))

keyboard-layout (par défaut : #f)

Si la valeur est #f, Xorg utilise la disposition du clavier par défaut — habituellement la disposition anglaise américaine (« qwerty ») pour un clavier de PC à 105 touches.

Sinon cela doit être un objet keyboard-layout spécifiant la disposition du clavier à utiliser lorsque Xorg tourne. Voir Disposition du clavier pour plus d’informations sur la manière de spécifier la disposition du clavier.

extra-config (par défaut : '())

C’est une liste de chaînes de caractères ou d’objets ajoutés au fichier de configuration. Elle est utile pour ajouter du texte supplémentaire directement dans le fichier de configuration.

server (par défaut : xorg-server)

C’est le paquet fournissant le serveur Xorg.

server-arguments (par défaut : %default-xorg-server-arguments)

Liste d’arguments de la ligne de commande supplémentaires à passer au serveur X. La valeur par défaut est -nolisten tcp.

Procédure Scheme : set-xorg-configuration config [login-manager-service-type]

Dit au gestionnaire de connexion (de type login-manager-service-type) d’utiliser config, un enregistrement <xorg-configuration>.

Comme la configuration Xog est incluse dans la configuration du gestionnaire de connexion — p. ex. gdm-configuration — cette procédure fournit un raccourci pour configurer Xorg.

Procédure Scheme : xorg-start-command [config]

Renvoie un script startx dans lequel les modules, les polices, etc., spécifiés dans config sont disponibles. Le résultat devrait être utilisé à la place de startx.

Habituellement le serveur X est démarré par un gestionnaire de connexion.

Procédure Scheme : screen-locker-service package [program]

Ajoute package, un paquet pour un verrouiller l’écran ou un économiseur d’écran dont la commande est program, à l’ensemble des programmes setuid et lui ajoute une entrée PAM. Par exemple :

(screen-locker-service xlockmore "xlock")

rend utilisable le bon vieux XlockMore.


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

8.8.6 Services d’impression

Le module (gnu services cups) fournit une définition de service Guix pour le service d’impression CUPS. Pour ajouter la prise en charge d’une imprimante à un système Guix, ajoutez un cups-service à la définition du système d’exploitation :

Variable Scheme : cups-service-type

Le type de service pour un serveur d’impression CUPS. Sa valeur devrait être une configuration CUPS valide (voir plus bas). Pour utiliser les paramètres par défaut, écrivez simplement :

(service cups-service-type)

La configuration de CUPS contrôle les paramètres de base de votre installation CUPS : sur quelles interfaces il doit écouter, que faire si un travail échoue, combien de journalisation il faut faire, etc. Pour ajouter une imprimante, vous devrez visiter l’URL http://localhost:631 ou utiliser un outil comme les services de configuration d’imprimante de GNOME. Par défaut, la configuration du service CUPS générera un certificat auto-signé si besoin, pour les connexions sécurisée avec le serveur d’impression.

Supposons que vous souhaitiez activer l’interface Web de CUPS et ajouter le support pour les imprimantes Epson via le paquet escpr et pour les imprimantes HP via le paquet hplip-minimal. Vous pouvez le faire directement, comme ceci (vous devez utiliser le module (gnu packages cups)) :

(service cups-service-type
         (cups-configuration
           (web-interface? #t)
           (extensions
             (list cups-filters escpr hplip-minimal))))

Remarque : si vous souhaitez utiliser la GUI basée sur Qt5 qui provient du paquet hplip, nous vous suggérons d’installer le paquet hplip, soit dans votre configuration d’OS, soit en tant qu’utilisateur.

Les paramètres de configuration disponibles sont les suivants. Chaque définition des paramètres est précédé par son type ; par exemple, ‘string-list foo’ indique que le paramètre foo devrait être spécifié comme une liste de chaînes de caractères. Il y a aussi une manière de spécifier la configuration comme une chaîne de caractères, si vous avez un vieux fichier cupsd.conf que vous voulez porter depuis un autre système ; voir la fin pour plus de détails.

Les champs de cups-configuration disponibles sont :

paramètre de cups-configuration : package cups

Le paquet CUPS.

paramètre de cups-configuration : package-list extensions

Pilotes et autres extensions du paquet CUPS.

paramètre de cups-configuration : files-configuration files-configuration

Configuration de l’emplacement où écrire les journaux, quels répertoires utiliser pour les travaux d’impression et les paramètres de configuration privilégiés liés.

Les champs files-configuration disponibles sont :

paramètre de files-configuration : log-location access-log

Définit le fichier de journal d’accès. Spécifier un nom de fichier vide désactive la génération de journaux d’accès. La valeur stderr fait que les entrées du journal seront envoyés sur l’erreur standard lorsque l’ordonnanceur est lancé au premier plan ou vers le démon de journal système lorsqu’il tourne en tache de fond. La valeur syslog fait que les entrées du journal sont envoyées au démon de journalisation du système. Le nom du serveur peut être inclus dans les noms de fichiers avec la chaîne %s, comme dans /var/log/cups/%s-access_log.

La valeur par défaut est ‘"/var/log/cups/access_log"’.

paramètre de files-configuration : file-name cache-dir

L’emplacement où CUPS devrait mettre les données en cache.

La valeur par défaut est ‘"/var/cache/cups"’.

paramètre de files-configuration : string config-file-perm

Spécifie les permissions pour tous les fichiers de configuration que l’ordonnanceur écrit.

Remarquez que les permissions pour le fichier printers.conf sont actuellement masqués pour ne permettre que l’accès par l’utilisateur de l’ordonnanceur (typiquement root). La raison est que les URI des imprimantes contiennent des informations d’authentification sensibles qui ne devraient pas être connues sur le système. Il n’est pas possible de désactiver cette fonctionnalité de sécurité.

La valeur par défaut est ‘"0640"’.

paramètre de files-configuration : log-location error-log

Définit le fichier de journal d’erreur. Spécifier un nom de fichier vide désactive la génération de journaux d’erreur. La valeur stderr fait que les entrées du journal seront envoyés sur l’erreur standard lorsque l’ordonnanceur est lancé au premier plan ou vers le démon de journalisation du système lorsqu’il tourne en tache de fond. La valeur syslog fait que les entrées du journal sont envoyées au démon de journalisation du système. Le nom du serveur peut être inclus dans les noms de fichiers avec la chaîne %s, comme dans /var/log/cups/%s-error_log.

La valeur par défaut est ‘"/var/log/cups/error_log"’.

paramètre de files-configuration : string fatal-errors

Spécifie quelles erreurs sont fatales, qui font terminer l’ordonnanceur. Les types de chaînes sont :

none

Aucune erreur n’est fatale.

all

Toutes les erreurs ci-dessous sont fatales.

browse

Les erreurs d’initialisation de la navigation sont fatales, par exemple les connexion échouées au démon DNS-SD.

config

Les erreurs de syntaxe du fichier de configuration sont fatale.

listen

Les erreurs d’écoute ou de port sont fatales, sauf pour les erreurs d’IPv6 sur la boucle locale ou les adresses any.

log

Les erreurs de création ou d’écriture des fichiers de journal sont fatales.

permissions

Les mauvaises permissions des fichiers de démarrage sont fatales, par exemple un certificat TLS et des fichiers de clefs avec des permissions permettant la lecture à tout le monde.

La valeur par défaut est ‘"all -browse"’.

paramètre de files-configuration : boolean file-device?

Spécifie si le fichier de pseudo-périphérique peut être utilisé pour de nouvelles queues d’impression. L’URI file:///dev/null est toujours permise.

La valeur par défaut est ‘#f’.

paramètre de files-configuration : string group

Spécifie le nom ou l’ID du groupe qui sera utilisé lors de l’exécution de programmes externes.

La valeur par défaut est ‘"lp"’.

paramètre de files-configuration : string log-file-perm

Spécifie les permissions pour tous les fichiers de journal que l’ordonnanceur écrit.

La valeur par défaut est ‘"0644"’.

paramètre de files-configuration : log-location page-log

Définit le fichier de journal de page. Spécifier un nom de fichier vide désactive la génération de journaux de pages. La valeur stderr fait que les entrées du journal seront envoyés sur l’erreur standard lorsque l’ordonnanceur est lancé au premier plan ou vers le démon de journal système lorsqu’il tourne en tache de fond. La valeur syslog fait que les entrées du journal sont envoyées au démon de journalisation du système. Le nom du serveur peut être inclus dans les noms de fichiers avec la chaîne %s, comme dans /var/log/cups/%s-page_log.

La valeur par défaut est ‘"/var/log/cups/page_log"’.

paramètre de files-configuration : string remote-root

Spécifie le nom d’utilisateur associé aux accès non authentifiés par des clients qui se disent être l’utilisateur root. La valeur par défaut est remroot.

La valeur par défaut est ‘"remroot"’.

paramètre de files-configuration : file-name request-root

Spécifie le répertoire qui contient les travaux d’impression et d’autres données des requêtes HTTP.

La valeur par défaut est ‘"/var/spool/cups"’.

paramètre de files-configuration : sandboxing sandboxing

Spécifie le niveau d’isolation de sécurité appliqué aux filtres d’impression, aux moteurs et aux autres processus fils de l’ordonnanceur ; soit relaxed soit strict. Cette directive n’est actuellement utilisée et supportée que sur macOS.

La valeur par défaut est ‘strict’.

paramètre de files-configuration : file-name server-keychain

Spécifie l’emplacement des certifications TLS et des clefs privées. CUPS cherchera les clefs publiques et privées dans ce répertoire : un fichier .crt pour un certificat encodé en PEM et le fichier .key correspondant pour la clef privée encodée en PEM.

La valeur par défaut est ‘"/etc/cups/ssl"’.

paramètre de files-configuration : file-name server-root

Spécifie le répertoire contenant les fichiers de configuration du serveur.

La valeur par défaut est ‘"/etc/cups"’.

paramètre de files-configuration : boolean sync-on-close?

Spécifie si l’ordonnanceur appelle fsync(2) après avoir écrit la configuration ou les fichiers d’état.

La valeur par défaut est ‘#f’.

paramètre de files-configuration : space-separated-string-list system-group

Spécifie le groupe ou les groupes à utiliser pour l’authentification du groupe @SYSTEM.

paramètre de files-configuration : file-name temp-dir

Spécifie le répertoire où les fichiers temporaires sont stockés.

La valeur par défaut est ‘"/var/spool/cups/tmp"’.

paramètre de files-configuration : string user

Spécifie le nom d’utilisateur ou l’ID utilisé pour lancer des programmes externes.

La valeur par défaut est ‘"lp"’.

files-configuration parameter : string set-env

Indique que la variable d’environnement spécifiée doit être passée aux processus fils.

La valeur par défaut est ‘"variable value"’.

paramètre de cups-configuration : access-log-level access-log-level

Spécifie le niveau de journalisation pour le fichier AccessLog. Le niveau config enregistre les ajouts, suppressions et modifications d’imprimantes et de classes et lorsque les fichiers de configuration sont accédés ou mis à jour. Le niveau actions enregistre la soumission, la suspension, la libération, la modification et l’annulation des travaux et toutes les conditions de config. Le niveau all enregistre toutes les requêtes.

La valeur par défaut est ‘actions’.

paramètre de cups-configuration : boolean auto-purge-jobs?

Spécifie s’il faut vider l’historique des travaux automatiquement lorsqu’il n’est plus nécessaire pour les quotas.

La valeur par défaut est ‘#f’.

cups-configuration parameter : comma-separated-string-list browse-dns-sd-sub-types

Specifies a list of DNS-SD sub-types to advertise for each shared printer. For example, ‘"_cups" "_print"’ will tell network clients that both CUPS sharing and IPP Everywhere are supported.

Defaults to ‘"_cups"’.

paramètre de cups-configuration : browse-local-protocols browse-local-protocols

Spécifie les protocoles à utiliser pour partager les imprimantes sur le réseau local.

La valeur par défaut est ‘dnssd’.

paramètre de cups-configuration : boolean browse-web-if?

Spécifie si l’interface web de CUPS est publiée.

La valeur par défaut est ‘#f’.

paramètre de cups-configuration : boolean browsing?

Spécifie si les imprimantes partagées sont publiées.

La valeur par défaut est ‘#f’.

paramètre de cups-configuration : string classification

Spécifie la classification de sécurité du serveur. N’importe quel nom de bannière peut être utilisé, comme « classifié », « confidentiel », « secret », « top secret » et « déclassifié » ou la bannière peut être omise pour désactiver les fonctions d’impression sécurisées.

La valeur par défaut est ‘""’.

paramètre de cups-configuration : boolean classify-override?

Spécifie si les utilisateurs peuvent remplacer la classification (page de couverture) des travaux d’impression individuels avec l’option job-sheets.

La valeur par défaut est ‘#f’.

paramètre de cups-configuration : default-auth-type default-auth-type

Spécifie le type d’authentification par défaut à utiliser.

La valeur par défaut est ‘Basic’.

paramètre de cups-configuration : default-encryption default-encryption

Spécifie si le chiffrement sera utilisé pour les requêtes authentifiées.

La valeur par défaut est ‘Required’.

paramètre de cups-configuration : string default-language

Spécifie la langue par défaut à utiliser pour le contenu textuel et web.

La valeur par défaut est ‘"en"’.

paramètre de cups-configuration : string default-paper-size

Spécifie la taille de papier par défaut pour les nouvelles queues d’impression. ‘"Auto"’ utilise la valeur par défaut du paramètre de régionalisation, tandis que ‘"None"’ spécifie qu’il n’y a pas de taille par défaut. Des noms de tailles spécifique sont par exemple ‘"Letter"’ et ‘"A4"’.

La valeur par défaut est ‘"Auto"’.

paramètre de cups-configuration : string default-policy

Spécifie la politique d’accès par défaut à utiliser.

La valeur par défaut est ‘"default"’.

paramètre de cups-configuration : boolean default-shared?

Spécifie si les imprimantes locales sont partagées par défaut.

La valeur par défaut est ‘#t’.

paramètre de cups-configuration : non-negative-integer dirty-clean-interval

Spécifie le délai pour mettre à jour les fichiers de configuration et d’état. Une valeur de 0 fait que la mise à jour arrive aussi vite que possible, typiquement en quelques millisecondes.

La valeur par défaut est ‘30’.

paramètre de cups-configuration : error-policy error-policy

Specifies what to do when an error occurs. Possible values are abort-job, which will discard the failed print job; retry-job, which will retry the job at a later time; retry-current-job, which retries the failed job immediately; and stop-printer, which stops the printer.

La valeur par défaut est ‘stop-printer’.

paramètre de cups-configuration : non-negative-integer filter-limit

Spécifie le coût maximum des filtres qui sont lancés en même temps, pour minimiser les problèmes de ressources de disque, de mémoire et de CPU. Une limite de 0 désactive la limite de filtrage. Une impression standard vers une imprimante non-PostScript requiert une limite de filtre d’environ 200. Une imprimante PostScript requiert environ la moitié (100). Mettre en place la limite en dessous de ces valeurs limitera l’ordonnanceur à un seul travail d’impression à la fois.

La valeur par défaut est ‘0’.

paramètre de cups-configuration : non-negative-integer filter-nice

Spécifie la priorité des filtres de l’ordonnanceur qui sont lancés pour imprimer un travail. La valeur va de 0, la plus grande priorité, à 19, la plus basse priorité.

La valeur par défaut est ‘0’.

paramètre de cups-configuration : host-name-lookups host-name-lookups

Spécifie s’il faut faire des résolutions inverses sur les clients qui se connectent. Le paramètre double fait que cupsd vérifie que le nom d’hôte résolu depuis l’adresse correspond à l’une des adresses renvoyées par ce nom d’hôte. Les résolutions doubles évitent aussi que des clients avec des adresses non enregistrées ne s’adressent à votre serveur. N’initialisez cette valeur qu’à #t ou double que si c’est absolument nécessaire.

La valeur par défaut est ‘#f’.

paramètre de cups-configuration : non-negative-integer job-kill-delay

Spécifie le nombre de secondes à attendre avant de tuer les filtres et les moteurs associés avec un travail annulé ou suspendu.

La valeur par défaut est ‘30’.

paramètre de cups-configuration : non-negative-integer job-retry-interval

Spécifie l’intervalle des nouvelles tentatives en secondes. C’est typiquement utilisé pour les queues de fax mais peut aussi être utilisé avec des queues d’impressions normales dont la politique d’erreur est retry-job ou retry-current-job.

La valeur par défaut est ‘30’.

paramètre de cups-configuration : non-negative-integer job-retry-limit

Spécifie le nombre de nouvelles tentatives pour les travaux. C’est typiquement utilisé pour les queues de fax mais peut aussi être utilisé pour les queues d’impressions dont la politique d’erreur est retry-job ou retry-current-job.

La valeur par défaut est ‘5’.

paramètre de cups-configuration : boolean keep-alive?

Spécifie s’il faut supporter les connexion HTTP keep-alive.

La valeur par défaut est ‘#t’.

paramètre de cups-configuration : non-negative-integer keep-alive-timeout

Spécifie combien de temps les connexions inactives avec les clients restent ouvertes, en secondes.

La valeur par défaut est ‘30’.

paramètre de cups-configuration : non-negative-integer limit-request-body

Spécifie la taille maximale des fichiers à imprimer, des requêtes IPP et des données de formulaires HTML. Une limite de 0 désactive la vérification de la limite.

La valeur par défaut est ‘0’.

paramètre de cups-configuration : multiline-string-list listen

Écoute sur les interfaces spécifiées. Les valeurs valides sont de la forme adresse:port, où adresse est soit une adresse IPv6 dans des crochets, soit une adresse IPv4, soit * pour indiquer toutes les adresses. Les valeurs peuvent aussi être des noms de fichiers de socket UNIX domain. La directive Listen est similaire à la directive Port mais vous permet de restreindre l’accès à des interfaces ou des réseaux spécifiques.

paramètre de cups-configuration : non-negative-integer listen-back-log

Spécifie le nombre de connexions en attente qui seront permises. Ça n’affecte normalement que les serveurs très actifs qui ont atteint la limite MaxClients, mais peut aussi être déclenché par un grand nombre de connexions simultanées. Lorsque la limite est atteinte, le système d’exploitation refusera les connexions supplémentaires jusqu’à ce que l’ordonnanceur accepte les connexions en attente.

La valeur par défaut est ‘128’.

paramètre de cups-configuration : location-access-control-list location-access-controls

Spécifie un ensemble de contrôles d’accès supplémentaires.

Les champs de location-access-controls disponibles sont :

paramètre de location-access-controls : file-name path

Spécifie le chemin d’URI auquel les contrôles d’accès s’appliquent.

paramètre de location-access-controls : access-control-list access-controls

Les contrôles d’accès pour tous les accès à ce chemin, dans le même format que le champ access-controls de operation-access-control.

La valeur par défaut est ‘()’.

paramètre de location-access-controls : method-access-control-list method-access-controls

Contrôles d’accès pour les accès spécifiques à la méthode à ce chemin.

La valeur par défaut est ‘()’.

Les champs de method-access-controls disponibles sont :

paramètre de method-access-controls : boolean reverse?

Si la valeur est #t, applique les contrôles d’accès à toutes les méthodes sauf les méthodes listées. Sinon, applique le contrôle uniquement aux méthodes listées.

La valeur par défaut est ‘#f’.

paramètre de method-access-controls : method-list methods

Les méthodes auxquelles ce contrôle d’accès s’applique.

La valeur par défaut est ‘()’.

paramètre de method-access-controls : access-control-list access-controls

Directives de contrôle d’accès, comme une liste de chaînes de caractères. Chaque chaîne devrait être une directive, comme « Order allow, deny ».

La valeur par défaut est ‘()’.

paramètre de cups-configuration : non-negative-integer log-debug-history

Spécifie le nombre de messages de débogage qui sont retenu pour la journalisation si une erreur arrive dans un travail d’impression. Les messages de débogage sont journalisés indépendamment du paramètre LogLevel.

La valeur par défaut est ‘100’.

paramètre de cups-configuration : log-level log-level

Spécifie le niveau de journalisation du fichier ErrorLog. La valeur none arrête toute journalisation alors que que debug2 enregistre tout.

La valeur par défaut est ‘info’.

paramètre de cups-configuration : log-time-format log-time-format

Spécifie le format de la date et de l’heure dans les fichiers de journaux. La valeur standard enregistre les secondes entières alors que usecs enregistre les microsecondes.

La valeur par défaut est ‘standard’.

paramètre de cups-configuration : non-negative-integer max-clients

Spécifie le nombre maximum de clients simultanés qui sont autorisés par l’ordonnanceur.

La valeur par défaut est ‘100’.

paramètre de cups-configuration : non-negative-integer max-clients-per-host

Spécifie le nombre maximum de clients simultanés permis depuis une même adresse.

La valeur par défaut est ‘100’.

paramètre de cups-configuration : non-negative-integer max-copies

Spécifie le nombre maximum de copies qu’un utilisateur peut imprimer pour chaque travail.

La valeur par défaut est ‘9999’.

paramètre de cups-configuration : non-negative-integer max-hold-time

Spécifie la durée maximum qu’un travail peut rester dans l’état de suspension indefinite avant qu’il ne soit annulé. La valeur 0 désactive l’annulation des travaux suspendus.

La valeur par défaut est ‘0’.

paramètre de cups-configuration : non-negative-integer max-jobs

Spécifie le nombre maximum de travaux simultanés autorisés. La valeur 0 permet un nombre illimité de travaux.

La valeur par défaut est ‘500’.

paramètre de cups-configuration : non-negative-integer max-jobs-per-printer

Spécifie le nombre maximum de travaux simultanés autorisés par imprimante. La valeur 0 permet au plus MaxJobs travaux par imprimante.

La valeur par défaut est ‘0’.

paramètre de cups-configuration : non-negative-integer max-jobs-per-user

Spécifie le nombre maximum de travaux simultanés permis par utilisateur. La valeur 0 permet au plus MaxJobs travaux par utilisateur.

La valeur par défaut est ‘0’.

paramètre de cups-configuration : non-negative-integer max-job-time

Spécifie la durée maximum qu’un travail peut prendre avant qu’il ne soit annulé, en secondes. Indiquez 0 pour désactiver l’annulation des travaux « coincés ».

La valeur par défaut est ‘10800’.

paramètre de cups-configuration : non-negative-integer max-log-size

Spécifie la taille maximale des fichiers de journaux avant qu’on ne les fasse tourner, en octets. La valeur 0 désactive la rotation.

La valeur par défaut est ‘1048576’.

paramètre de cups-configuration : non-negative-integer multiple-operation-timeout

Spécifie la durée maximale à permettre entre les fichiers d’un travail en contenant plusieurs, en secondes.

La valeur par défaut est ‘300’.

paramètre de cups-configuration : string page-log-format

Spécifie le format des lignes PageLog. Les séquences qui commencent par un pourcent (‘%’) sont remplacées par l’information correspondante, tandis que les autres caractères sont copiés littéralement. Les séquences pourcent suivantes sont reconnues :

%%

insère un seul caractères pourcent

%{name}

insère la valeur de l’attribut IPP spécifié

%C

insère le nombre de copies pour la page actuelle

%P

insère le numéro de page actuelle

%T

insère la date et l’heure actuelle dans un format de journal commun

%j

insère l’ID du travail

%p

insère le nom de l’imprimante

%u

insère le nom d’utilisateur

Si la valeur est la chaîne vide, le PageLog est désactivée. La chaîne %p %u %j %T %P %C %{job-billing} %{job-originating-host-name} %{job-name} %{media} %{sides} crée un PageLog avec les entrées standards.

La valeur par défaut est ‘""’.

paramètre de cups-configuration : environment-variables environment-variables

Passe les variables d’environnement spécifiées aux processus fils ; une liste de chaînes de caractères.

La valeur par défaut est ‘()’.

paramètre de cups-configuration : policy-configuration-list policies

Spécifie des politiques de contrôle d’accès nommées.

Les champs de policy-configuration disponibles sont :

paramètre de policy-configuration : string name

Nom de la politique.

paramètre de policy-configuration : string job-private-access

Spécifie une liste d’accès pour les valeurs privées du travail. @ACL correspond aux valeurs requesting-user-name-allowed ou requesting-user-name-denied de l’imprimante. @OWNER correspond au propriétaire du travail. @SYSTEM correspond aux groupes listés dans le champ system-group de la configuration files-config, qui est réifié dans le fichier cups-files.conf(5). Les autres éléments possibles de la liste d’accès sont des noms d’utilisateurs spécifiques et @group pour indiquer les membres d’un groupe spécifique. La liste d’accès peut aussi être simplement all ou default.

La valeur par défaut est ‘"@OWNER @SYSTEM"’.

paramètre de policy-configuration : string job-private-values

Spécifie la liste des valeurs de travaux à rendre privée, ou all, default, ou none.

La valeur par défaut est ‘"job-name job-originating-host-name job-originating-user-name phone"’.

paramètre de policy-configuration : string subscription-private-access

Spécifie un liste d’accès pour les valeurs privées de la souscription. @ACL correspond aux valeurs requesting-user-name-allowed ou requesting-user-name-denied de l’imprimante. @OWNER correspond au propriétaire du travail. @SYSTEM correspond aux groupes listés dans le champ system-group de la configuration files-config, qui est réifié dans le fichier cups-files.conf(5). Les autres éléments possibles de la liste d’accès sont des noms d’utilisateurs spécifiques et @group pour indiquer les membres d’un groupe spécifique. La liste d’accès peut aussi être simplement all ou default.

La valeur par défaut est ‘"@OWNER @SYSTEM"’.

paramètre de policy-configuration : string subscription-private-values

Spécifie la liste des valeurs de travaux à rendre privée, ou all, default, ou none.

La valeur par défaut est ‘"notify-events notify-pull-method notify-recipient-uri notify-subscriber-user-name notify-user-data"’.

paramètre de policy-configuration : operation-access-control-list access-controls

Contrôle d’accès par les actions IPP.

La valeur par défaut est ‘()’.

paramètre de cups-configuration : boolean-or-non-negative-integer preserve-job-files

Spécifie si les fichiers de travaux (les documents) sont préservés après qu’un travail est imprimé. Si une valeur numérique est spécifiée, les fichiers de travaux sont préservés pour le nombre de secondes indiquées après l’impression. Sinon, une valeur booléenne s’applique indéfiniment.

La valeur par défaut est ‘86400’.

paramètre de cups-configuration : boolean-or-non-negative-integer preserve-job-history

Spécifie si l’historique des travaux est préservé après qu’un travail est imprimé. Si une valeur numérique est spécifiée, l’historique des travaux est préservé pour le nombre de secondes indiquées après l’impression. Si la valeur est #t, l’historique des travaux est préservé jusqu’à atteindre la limite MaxJobs.

La valeur par défaut est ‘#t’.

paramètre de cups-configuration : non-negative-integer reload-timeout

Spécifie la durée d’attente pour la fin des travaux avant de redémarrer l’ordonnanceur.

La valeur par défaut est ‘30’.

paramètre de cups-configuration : string rip-cache

Spécifie la quantité de mémoire maximale à utiliser pour convertir des documents en bitmaps pour l’imprimante.

La valeur par défaut est ‘"128m"’.

paramètre de cups-configuration : string server-admin

Spécifie l’adresse de courriel de l’administrateur système.

La valeur par défaut est ‘"root@localhost.localdomain"’.

paramètre de cups-configuration : host-name-list-or-* server-alias

La directive ServerAlias est utilisée pour la validation des en-tête HTTP Host lorsque les clients se connectent à l’ordonnanceur depuis des interfaces externes. Utiliser le nom spécial * peut exposer votre système à des attaques connues de recombinaison DNS dans le navigateur, même lorsque vous accédez au site à travers un pare-feu. Si la découverte automatique des autres noms ne fonctionne pas, nous vous recommandons de lister chaque nom alternatif avec une directive SeverAlias plutôt que d’utiliser *.

La valeur par défaut est ‘*’.

paramètre de cups-configuration : string server-name

Spécifie le nom d’hôte pleinement qualifié du serveur.

La valeur par défaut est ‘"localhost"’.

paramètre de cups-configuration : server-tokens server-tokens

Spécifie les informations incluses dans les en-têtes Server des réponses HTTP. None désactive l’en-tête Server. ProductOnly rapporte CUPS. Major rapporte CUPS 2. Minor rapporte CUPS 2.0. Minimal rapporte CUPS 2.0.0. OS rapporte CUPS 2.0.0 (uname)uname est la sortie de la commande uname. Full rapporte CUPS 2.0.0 (uname) IPP/2.0.

La valeur par défaut est ‘Minimal’.

paramètre de cups-configuration : multiline-string-list ssl-listen

Écoute des connexions chiffrées sur les interfaces spécifiées. Les valeurs valides sont de la forme adresse:port, où adresse est soit une adresse IPv6 dans des crochets, soit une adresse IPv4, soit * pour indiquer toutes les interfaces.

La valeur par défaut est ‘()’.

paramètre de cups-configuration : ssl-options ssl-options

Sets encryption options. By default, CUPS only supports encryption using TLS v1.0 or higher using known secure cipher suites. Security is reduced when Allow options are used, and enhanced when Deny options are used. The AllowRC4 option enables the 128-bit RC4 cipher suites, which are required for some older clients. The AllowSSL3 option enables SSL v3.0, which is required for some older clients that do not support TLS v1.0. The DenyCBC option disables all CBC cipher suites. The DenyTLS1.0 option disables TLS v1.0 support - this sets the minimum protocol version to TLS v1.1.

La valeur par défaut est ‘()’.

paramètre de cups-configuration : boolean strict-conformance?

Spécifie si l’ordonnanceur demande aux clients d’adhérer aux spécifications IPP.

La valeur par défaut est ‘#f’.

paramètre de cups-configuration : non-negative-integer timeout

Spécifie le délai d’attente des requêtes HTTP, en secondes.

La valeur par défaut est ‘300’.

paramètre de cups-configuration : boolean web-interface?

Spécifie si l’interface web est activée.

La valeur par défaut est ‘#f’.

Maintenant, vous vous dîtes peut-être « oh la la, cher manuel de Guix, je t’aime bien mais arrête maintenant avec ces options de configuration »28. En effet. cependant, encore un point supplémentaire : vous pouvez avoir un fichier cupsd.conf existant que vous pourriez vouloir utiliser. Dans ce cas, vous pouvez passer un opaque-cups-configuration en configuration d’un cups-service-type.

Les champs de opaque-cups-configuration disponibles sont :

paramètre de opaque-cups-configuration : package cups

Le paquet CUPS.

paramètre de opaque-cups-configuration : string cupsd.conf

Le contenu de cupsd.conf, en tant que chaîne de caractères.

paramètre de opaque-cups-configuration : string cups-files.conf

Le contenu du fichier cups-files.conf, en tant que chaîne de caractères.

Par exemple, si vos fichiers cupsd.conf et cups-files.conf sont dans des chaînes du même nom, pouvez instancier un service CUPS de cette manière :

(service cups-service-type
         (opaque-cups-configuration
           (cupsd.conf cupsd.conf)
           (cups-files.conf cups-files.conf)))

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

8.8.7 Services de bureaux

Le module (gnu services desktop) fournit des services qui sont habituellement utiles dans le contexte d’une installation « de bureau » — c’est-à-dire sur une machine qui fait tourner un service d’affichage graphique, éventuellement avec des interfaces utilisateurs graphiques, etc. Il définit aussi des services qui fournissent des environnements de bureau spécifiques comme GNOME, Xfce et MATE.

Pour simplifier les choses, le module définit une variable contenant l’ensemble des services que les utilisateurs s’attendent en général à avoir sur une machine avec un environnement graphique et le réseau :

Variable Scheme : %desktop-services

This is a list of services that builds upon %base-services and adds or adjusts services for a typical “desktop” setup.

In particular, it adds a graphical login manager (voir gdm-service-type), screen lockers, a network management tool (voir network-manager-service-type) with modem support (voir modem-manager-service-type), energy and color management services, the elogind login and seat manager, the Polkit privilege service, the GeoClue location service, the AccountsService daemon that allows authorized users change system passwords, an NTP client (voir Services réseau), the Avahi daemon, and has the name service switch service configured to be able to use nss-mdns (voir mDNS).

The %desktop-services variable can be used as the services field of an operating-system declaration (voir services).

Additionally, the gnome-desktop-service-type, xfce-desktop-service, mate-desktop-service-type and enlightenment-desktop-service-type procedures can add GNOME, Xfce, MATE and/or Enlightenment to a system. To “add GNOME” means that system-level services like the backlight adjustment helpers and the power management utilities are added to the system, extending polkit and dbus appropriately, allowing GNOME to operate with elevated privileges on a limited number of special-purpose system interfaces. Additionally, adding a service made by gnome-desktop-service-type adds the GNOME metapackage to the system profile. Likewise, adding the Xfce service not only adds the xfce metapackage to the system profile, but it also gives the Thunar file manager the ability to open a “root-mode” file management window, if the user authenticates using the administrator’s password via the standard polkit graphical interface. To “add MATE” means that polkit and dbus are extended appropriately, allowing MATE to operate with elevated privileges on a limited number of special-purpose system interfaces. Additionally, adding a service of type mate-desktop-service-type adds the MATE metapackage to the system profile. “Adding Enlightenment” means that dbus is extended appropriately, and several of Enlightenment’s binaries are set as setuid, allowing Enlightenment’s screen locker and other functionality to work as expected.

Les environnement de bureau dans Guix utilisent le service d’affichage Xorg par défaut. Si vous voulez utiliser le protocol de serveur d’affichage plus récent Wayland, vous devez utiliser sddm-service à la place de GDM comme gestionnaire de connexion graphique. Vous devriez ensuite sélectionner la session « GNOME (Wayland) » dans SDDM. Autrement, vous pouvez essayer de démarrer GNOME sur Wayland manuellement depuis un TTY avec la commande XDG_SESSION_TYPE=wayland exec dbus-run-session gnome-session. Actuellement seul GNOME support Wayland.

Variable Scheme : gnome-desktop-service-type

C’est le type de service qui ajoute l’environnement de bureau GNOME. Sa valeur est un objet gnome-desktop-configuration (voir plus bas).

Ce service ajoute le paquet gnome au profil du système et étend polkit avec les actions de gnome-settings-daemon.

Type de données : gnome-desktop-configuration

Enregistrement de la configuration de l’environnement de bureau GNOME.

gnome (par défaut : gnome)

Le paquet GNOME à utiliser.

Variable Scheme : xfce-desktop-service-type

C’est le type de service qui lance l’environnement de bureau https://xfce.org/. Sa valeur est un objet xfce-desktop-configuration (voir plus bas).

Ce service ajoute le paquet xfce au profil du système et étend polkit avec la possibilité pour thunar de manipuler le système de fichier en root depuis une session utilisateur, après que l’utilisateur s’authentifie avec le mot de passe administrateur.

Type de données : xfce-desktop-configuration

Enregistrement de la configuration de l’environnement de bureau Xfce.

xfce (par défaut : xfce)

Le paquet Xfce à utiliser.

Variable Scheme : mate-desktop-service-type

C’est le type de service qui lance l’environnement de bureau MATE. Sa valeur est un objet mate-desktop-configuration (voir plus bas).

Ce service ajoute le paquet mate au profil du système, et étend polkit avec les actions de mate-settings-daemon.

Type de données : mate-desktop-configuration

Enregistrement de configuration pour l’environnement de bureau MATE.

mate (par défaut : mate)

Le paquet MATE à utiliser.

Variable Scheme : enlightenment-desktop-service-type

Renvoie un service qui ajoute le paquet enlightenment et étend dbus avec les actions de efl

Type de données : enlightenment-desktop-service-configuration
enlightenment (par défaut : enlightenment)

Le paquet enlightenment à utiliser.

Comme les services de bureau GNOME, Xfce et MATE récupèrent tant de paquet, la variable %desktop-services par défaut n’inclut aucun d’entre eux. Pour ajouter GNOME, Xfce ou MATE, utilisez cons pour les ajouter à %desktop-services dans le champ services de votre operating-system :

(use-modules (gnu))
(use-service-modules desktop)
(operating-system
  ...
  ;; cons* ajoute des éléments à la liste donnée en dernier argument.
  (services (cons* (service gnome-desktop-service-type)
                   (service xfce-desktop-service)
                   %desktop-services))
  ...)

Ces environnements de bureau seront alors disponibles comme une option dans la fenêtre de connexion graphique.

Les définitions de service qui sont vraiment incluses dans %desktop-services et fournies par (gnu services dbus) et (gnu services desktop) sont décrites plus bas.

Procédure Scheme : dbus-service [#:dbus dbus] [#:services '()]

Renvoie un service qui lance le « bus système », dbus, avec le support de services.

D-Bus est un utilitaire de communication inter-processus. Son bus système est utilisé pour permettre à des services systèmes de communiquer et d’être notifiés d’événements systèmes.

services doit être une liste de paquets qui fournissent un répertoire etc/dbus-1/system.d contenant de la configuration D-Bus supplémentaire et des fichiers de politiques. Par exemple, pour permettre à avahi-daemon d’utiliser le bus système, services doit être égal à (list avahi).

Procédure Scheme : elogind-service [#:config config]

Renvoie un service qui lance le démon de gestion de connexion et de session elogind. Elogind expose une interface D-Bus qui peut être utilisée pour connaître quels utilisateurs sont connectés, le type de session qu’ils sont ouverte, suspendre le système, désactiver la veille système, redémarrer le système et d’autre taches.

Elogind gère la plupart des événements liés à l’énergie du système, par exemple mettre en veille le système quand l’écran est rabattu ou en l’éteignant quand le bouton de démarrage est appuyé.

L’argument config spécifie la configuration d’elogind et devrait être le résultat d’une invocation de (elogind-configuration (parameter value)...). Les paramètres disponibles et leur valeur par défaut sont :

kill-user-processes?

#f

kill-only-users

()

kill-exclude-users

("root")

inhibit-delay-max-seconds

5

handle-power-key

poweroff

handle-suspend-key

suspend

handle-hibernate-key

hibernate

handle-lid-switch

suspend

handle-lid-switch-docked

ignore

power-key-ignore-inhibited?

#f

suspend-key-ignore-inhibited?

#f

hibernate-key-ignore-inhibited?

#f

lid-switch-ignore-inhibited?

#t

holdoff-timeout-seconds

30

idle-action

ignore

idle-action-seconds

(* 30 60)

runtime-directory-size-percent

10

runtime-directory-size

#f

remove-ipc?

#t

suspend-state

("mem" "standby" "freeze")

suspend-mode

()

hibernate-state

("disk")

hibernate-mode

("platform" "shutdown")

hybrid-sleep-state

("disk")

hybrid-sleep-mode

("suspend" "platform" "shutdown")

Procédure Scheme : accountsservice-service [#:accountsservice accountsservice]

Renvoie un service qui lance AccountsService, un service système qui peut lister les comptes disponibles, changer leur mot de passe, etc. AccountsService s’intègre à Polkit pour permettre aux utilisateurs non privilégiés de pouvoir modifier la configuration de leur système. le site de accountsservice pour trouver plus d’informations.

L’argument accountsservice est le paquet accountsservice à exposer comme un service.

Procédure Scheme : polkit-service [#:polkit polkit]

Renvoie un service qui lance le service de gestion des privilèges Polkit, qui permet aux administrateurs systèmes de permettre l’accès à des opération privilégiées d’une manière structurée. En demandant au service Polkit, un composant système privilégié peut savoir lorsqu’il peut donner des privilèges supplémentaires à des utilisateurs normaux. Par exemple, un utilisateur normal peut obtenir le droit de mettre le système en veille si l’utilisateur est connecté localement.

Scheme Variable : polkit-wheel-service

Service that adds the wheel group as admins to the Polkit service. This makes it so that users in the wheel group are queried for their own passwords when performing administrative actions instead of root’s, similar to the behaviour used by sudo.

Variable Scheme : upower-service-type

Service qui lance upowerd, un moniteur système de consommation d’énergie et de niveau de batterie, avec les paramètres de configuration donnés.

Il implémente l’interface D-Bus org.freedesktop.UPower et est notamment utilisé par GNOME.

Type de données : upower-configuration

Type de données représentant la configuration de UPower.

upower (par défaut : upower)

Paquet à utiliser pour upower.

watts-up-pro? (par défaut : #f)

Active le périphérique Watts Up Pro.

poll-batteries? (par défaut : #t)

Active les requêtes au noyau pour les changements de niveau de batterie.

ignore-lid? (par défaut : #f)

Ignore l’état de l’écran, ce qui peut être utile s’il est incorrect sur un appareil.

use-percentage-for-policy? (par défaut : #f)

Indique si la politique de batterie basée sur le pourcentage devrait être utilisée. La valeur par défaut est d’utiliser la durée restante, changez en #t pour utiliser les pourcentages.

percentage-low (par défaut : 10)

Lorsque use-percentage-for-policy? est #t, cela indique à quel niveau la batterie est considérée comme faible.

percentage-critical (par défaut : 3)

Lorsque use-percentage-for-policy? est #t, cela indique à quel niveau la batterie est considérée comme critique.

percentage-action (par défaut : 2)

Lorsque use-percentage-for-policy? est #t, cela indique à quel niveau l’action sera prise.

time-low (par défaut : 1200)

Lorsque use-percentage-for-policy? est #f, cela indique à quelle durée restante en secondes la batterie est considérée comme faible.

time-critical (par défaut : 300)

Lorsque use-percentage-for-policy? est #f, cela indique à quelle durée restante en secondes la batterie est considérée comme critique.

time-action (par défaut : 120)

Lorsque use-percentage-for-policy? est #f, cela indique à quelle durée restante en secondes l’action sera prise.

critical-power-action (par défaut : 'hybrid-sleep)

L’action à prendre lorsque percentage-action ou time-action est atteint (en fonction de la configuration de use-percentage-for-policy?).

Les valeurs possibles sont :

  • 'power-off
  • 'hibernate
  • 'hybrid-sleep.
Procédure Scheme : udisks-service [#:udisks udisks]

Renvoie un service pour UDisks, un démon de gestion de disques qui fournit des notifications et la capacité de monter et démonter des disques à des interfaces utilisateurs. Les programmes qui parlent à UDisks sont par exemple la commande udisksctl, qui fait partie de UDisks et GNOME Disks.

Scheme Variable : colord-service-type

This is the type of the service that runs colord, a system service with a D-Bus interface to manage the color profiles of input and output devices such as screens and scanners. It is notably used by the GNOME Color Manager graphical tool. See the colord web site for more information.

Procédure Scheme : geoclue-application name [#:allowed? #t] [#:system? #f] [#:users '()]

Renvoie une configuration qui permet d’accéder aux données de localisation de GeoClue. name est l’ID Desktop de l’application, sans la partie en .desktop. Si allowed? est vraie, l’application aura droit d’accéder aux informations de localisation par défaut. Le booléen system? indique si une application est un composant système ou non. Enfin users est la liste des UID des utilisateurs pour lesquels cette application a le droit d’accéder aux informations de géolocalisation. Une liste d’utilisateurs vide indique que tous les utilisateurs sont autorisés.

Scheme Procedure : sane-service-type

This service provides access to scanners via SANE by installing the necessary udev rules.

Variable Scheme : %standard-geoclue-applications

La liste standard de configuration des application GeoClue connues, qui permet à l’utilitaire date-and-time de GNOME de demander l’emplacement actuel pour initialiser le fuseau horaire et aux navigateurs web IceCat et Epiphany de demander les informations de localisation. IceCat et Epiphany demandent tous deux à l’utilisateur avant de permettre à une page web de connaître l’emplacement de l’utilisateur.

Procédure Scheme : geoclue-service [#:colord colord] [#:whitelist '()] [#:wifi-geolocation-url

"https://location.services.mozilla.com/v1/geolocate?key=geoclue"]  [#:submit-data? #f] [#:wifi-submission-url "https://location.services.mozilla.com/v1/submit?key=geoclue"]  [#:submission-nick "geoclue"]  [#:applications %standard-geoclue-applications] Renvoie un service qui lance le service de géolocalisation GeoClue. Ce service fournit une interface D-Bus pour permettre aux applications de demande l’accès à la position de l’utilisateur et éventuellement d’ajouter des informations à des bases de données de géolocalisation en ligne. Voir le site web de GeoClue pour plus d’informations.

Procédure Scheme : bluetooth-service [#:bluez bluez] [#:auto-enable? #f]

Renvoie un service qui lance le démon bluetoothd qui gère tous les appareils Bluetooth et fournit un certain nombre d’interfaces D-Bus. Lorsque auto-enable? est vraie, le contrôler bluetooth est automatiquement alimenté au démarrage, ce qui peut être utile lorsque vous utilisez un clavier ou une souris bluetooth.

Les utilisateurs doivent être dans le groupe lp pour accéder au service D-Bus.

Scheme Variable : gnome-keyring-service-type

This is the type of the service that adds the GNOME Keyring. Its value is a gnome-keyring-configuration object (see below.)

This service adds the gnome-keyring package to the system profile and extends PAM with entries using pam_gnome_keyring.so, unlocking a user’s login keyring when they log in or setting its password with passwd.

Data Type : gnome-keyring-configuration

Configuration record for the GNOME Keyring service.

keyring (default: gnome-keyring)

The GNOME keyring package to use.

pam-services

A list of (service . kind) pairs denoting PAM services to extend, where service is the name of an existing service to extend and kind is one of login or passwd.

If login is given, it adds an optional pam_gnome_keyring.so to the auth block without arguments and to the session block with auto_start. If passwd is given, it adds an optional pam_gnome_keyring.so to the password block without arguments.

By default, this field contains “gdm-password” with the value login and “passwd” is with the value passwd.


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

8.8.8 Services de son

Le module (gnu services sound) fournit un service pour configurer le système ALSA (architecture son linux avancée), qui fait de PulseAudio le pilote de sortie préféré d’ALSA.

Variable Scheme : alsa-service-type

C’est le type pour le système Advanced Linux Sound Architecture (ALSA), qui génère le fichier de configuration /etc/asound.conf. La valeur de ce type est un enregistrement alsa-configuration comme dans cet exemple :

(service alsa-service-type)

Voir plus bas pour des détails sur alsa-configuration.

Type de données : alsa-configuration

Type de données représentant la configuration pour alsa-service.

alsa-plugins (par défaut : alsa-plugins)

Le paquet alsa-plugins à utiliser.

pulseaudio? (par défaut : #t)

Whether ALSA applications should transparently be made to use the PulseAudio sound server.

Utiliser PulseAudio vous permet dans lancer plusieurs applications qui produisent du son en même temps et de les contrôler individuellement via pavucontrol entre autres choses.

extra-options (par défaut : "")

Chaîne à ajouter au fichier /etc/asound.conf.

Les utilisateurs individuels qui veulent modifier la configuration système d’ALSA peuvent le faire avec le fichier ~/.asoundrc :

# Dans guix, il faut spécifier le chemin absolu des greffons.
pcm_type.jack {
  lib "/home/alice/.guix-profile/lib/alsa-lib/libasound_module_pcm_jack.so"
}

# Faire passer ALSA par Jack :
# <http://jackaudio.org/faq/routing_alsa.html>.
pcm.rawjack {
  type jack
  playback_ports {
    0 system:playback_1
    1 system:playback_2
  }

  capture_ports {
    0 system:capture_1
    1 system:capture_2
  }
}

pcm.!default {
  type plug
  slave {
    pcm "rawjack"
  }
}

Voir https://www.alsa-project.org/main/index.php/Asoundrc pour les détails.

Scheme Variable : pulseaudio-service-type

This is the type for the PulseAudio sound server. It exists to allow system overrides of the default settings via pulseaudio-configuration, see below.

Attention : This service on its own does not ensure, that the pulseaudio package exists on your machine. It merely adds configuration files for it, as detailed below. In the (admittedly unlikely) case, that you find yourself without a pulseaudio package, consider enabling it through the alsa-service-type above.

Data Type : pulseaudio-configuration

Data type representing the configuration for pulseaudio-service.

client-conf (default: '())

List of settings to set in client.conf. Accepts a list of strings or a symbol-value pairs. A string will be inserted as-is with a newline added. A pair will be formatted as “key = value”, again with a newline added.

daemon-conf (default: '((flat-volumes . no)))

List of settings to set in daemon.conf, formatted just like client-conf.

script-file (default: (file-append pulseaudio "/etc/pulse/default.pa"))

Script file to use as as default.pa.

system-script-file (default: (file-append pulseaudio "/etc/pulse/system.pa"))

Script file to use as as system.pa.

Scheme Variable : ladspa-service-type

This service sets the LADSPA_PATH variable, so that programs, which respect it, e.g. PulseAudio, can load LADSPA plugins.

The following example will setup the service to enable modules from the swh-plugins package:

(service ladspa-service-type
         (ladspa-configuration (plugins (list swh-plugins))))

See http://plugin.org.uk/ladspa-swh/docs/ladspa-swh.html for the details.


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

8.8.9 Services de bases de données

Le module (gnu services databases) fournit les services suivants.

Procédure Scheme : postgresql-service [#:postgresql postgresql] [#:config-file] [#:data-directory ``/var/lib/postgresql/data''] [#:port 5432] [#:locale ``en_US.utf8''] [#:extension-packages '()]

Renvoie un service qui lance postgresql, le service de bases de données PostgreSQL.

Le démon PostgreSQL charge sa configuration à l’exécution depuis config-file, crée une grappe de bases de données avec locale comme paramètre de régionalisation par défaut, stockée dans data-directory. Il écoute ensuite sur port.

Des extensions supplémentaires peuvent être chargées à partir de paquets listés dans extension-packages. Les extensions sont disponibles à l’exécution. Par exemple, pour créer une base de données géographique avec l’extension postgis, on peut configurer postgresql-service de cette manière :

(use-package-modules databases geo)

(operating-system
  ...
  ;; postgresql est requis pour lancer `psql' mais postgis n'est pas requis pour son
  ;; bon fonctionnement.
  (packages (cons* postgresql %base-packages))
  (services
    (cons*
      (postgresql-service #:extension-packages (list postgis))
      %base-services)))

Ensuite l’extension devient visible et vous pouvez initialiser une base de données géographique de cette manière :

psql -U postgres
> create database postgistest;
> \connect postgistest;
> create extension postgis;
> create extension postgis_topology;

Vous n’avez pas besoin d’ajouter ce champ pour les extensions « contrib » comme hstore ou dblink comme elles sont déjà exploitables par postgresql. Ce champ n’est requis que pour ajouter des extensions fournies par d’autres paquets.

Procédure Scheme : mysql-service [#:config (mysql-configuration)]

Renvoie un service qui lance mysqld, le service de bases de données MySQL ou MariaDB.

L’argument config facultatif spécifie la configuration de mysqld, qui devrait être un objet <mysql-configuration>.

Type de données : mysql-configuration

Type de données représentant la configuration de mysql-service.

mysql (par défaut : mariadb)

Objet paquet du serveur de base de données MySQL, qui peut être soit mariadb, soit mysql.

Pour MySQL, un mot de passe root temporaire sera affiché à l’activation. Pour MariaDB, le mot de passe root est vide.

port (par défaut : 3306)

Port TCP sur lequel le serveur de base de données écoute les connexions entrantes.

Variable Scheme : memcached-service-type

C’est le type de service pour le service Memcached qui fournit un cache en mémoire distribué. La valeur pour le type de service est un objet memcached-configuration.

(service memcached-service-type)
Type de données : memcached-configuration

Type de données représentant la configuration de memcached.

memcached (par défaut : memcached)

Le paquet Memcached à utiliser.

interfaces (par défaut : '("0.0.0.0"))

Les interfaces réseaux sur lesquelles écouter.

tcp-port (par défaut : 11211)

Port sur lequel accepter les connexions.

udp-port (par défaut : 11211)

Port sur lequel accepter les connexions UDP, une valeur de 0 désactive l’écoute en UDP.

additional-options (par défaut : '())

Options de la ligne de commande supplémentaires à passer à memcached.

Variable Scheme : mongodb-service-type

C’est le type de service pour MongoDB. La valeur de ce service est un objet mongodb-configuration.

(service mongodb-service-type)
Type de données : mongodb-configuration

Type de données représentant la configuration de mongodb.

mongodb (par défaut : mongodb)

Le paquet MongoDB à utiliser.

config-file (par défaut : %default-mongodb-configuration-file)

Le fichier de configuration pour MongoDB.

data-directory (par défaut : "/var/lib/mongodb")

Cette valeur est utilisée pour créer le répertoire, pour qu’il existe et appartienne à l’utilisateur mongodb. Il devrait correspondre au data-directory que MongoDB est configuré pour utiliser dans son fichier de configuration.

Variable Scheme : redis-service-type

C’est le type de service pour la base clef-valeur Redis dont la valeur est un objet redis-configuration.

Type de données : redis-configuration

Type de données représentant la configuration de redis.

redis (par défaut : redis)

Le paquet Redis à utiliser.

bind (par défaut : "127.0.0.1")

Interface réseau sur laquelle écouter.

port (par défaut : 6379)

Port sur lequel accepter les connexions, une valeur de 0 désactive l’écoute sur un socket TCP.

working-directory (par défaut : "/var/lib/redis")

Répertoire dans lequel stocker la base de données et les fichiers liés.


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

8.8.10 Services de courriels

Le module (gnu services mail) fournit des définitions de services Guix pour les services de courriel : des serveurs IMAP, POP3 et LMTP ainsi que des MTA (Mail Transport Agent). Que d’acronymes ! Ces services sont détaillés dans les sous-sections ci-dessous.

Service Dovecot

Procédure Scheme : dovecot-service [#:config (dovecot-configuration)]

Renvoie un service qui lance le serveur de courriel IMAP/POP3/LMTP Dovecot.

Par défaut, Dovecot n’a pas besoin de beaucoup de configuration ; l’objet de configuration par défaut créé par (dovecot-configuration) suffira si votre courriel est livré dans ~/Maildir. Un certificat auto-signé sera généré pour les connexions TLS, bien que Dovecot écoutera aussi sur les ports non chiffrés par défaut. Il y a quelques options cependant, que les administrateurs peuvent avoir besoin de changer et comme c’est le cas avec d’autres services, Guix permet aux administrateurs systèmes de spécifier ces paramètres via une interface Scheme unifiée.

Par exemple, pour spécifier que les courriels se trouvent dans maildir~/.mail, on peut instancier Dovecot de cette manière :

(dovecot-service #:config
                 (dovecot-configuration
                  (mail-location "maildir:~/.mail")))

Les paramètres de configuration disponibles sont les suivants. Chaque définition des paramètres est précédé par son type ; par exemple, ‘string-list foo’ indique que le paramètre foo devrait être spécifié comme une liste de chaînes de caractères. Il y a aussi une manière de spécifier la configuration comme une chaîne de caractères, si vous avez un vieux fichier dovecot.conf que vous voulez porter depuis un autre système ; voir la fin pour plus de détails.

Les champs de dovecot-configuration disponibles sont :

paramètre de dovecot-configuration : package dovecot

Le paquet dovecot.

paramètre de dovecot-configuration : comma-separated-string-list listen

Une liste d’IP ou d’hôtes à écouter pour les connexions. ‘*’ écoute sur toutes les interfaces IPv4, ‘::’ écoute sur toutes les interfaces IPv6. Si vous voulez spécifier des ports différents de la valeur par défaut ou quelque chose de plus complexe, complétez les champs d’adresse et de port de ‘inet-listener’ des services spécifiques qui vous intéressent.

paramètre de dovecot-configuration : protocol-configuration-list protocols

Liste des protocoles que vous voulez servir. Les protocoles disponibles comprennent ‘imap’, ‘pop3’ et ‘lmtp’.

Les champs protocol-configuration disponibles sont :

paramètre de protocol-configuration : string name

Le nom du protocole.

paramètre de protocol-configuration : string auth-socket-path

Le chemin d’un socket UNIX vers le serveur d’authentification maître pour trouver les utilisateurs. C’est utilisé par imap (pour les utilisateurs partagés) et lda. Sa valeur par défaut est ‘"/var/run/dovecot/auth-userdb"’.

paramètre de protocol-configuration : space-separated-string-list mail-plugins

Liste de greffons à charger séparés par des espaces.

paramètre de protocol-configuration : non-negative-integer mail-max-userip-connections

Nombre maximum de connexions IMAP permises pour un utilisateur depuis chaque adresse IP. Remarque : la comparaison du nom d’utilisateur est sensible à la casse. Par défaut ‘10’.

paramètre de dovecot-configuration : service-configuration-list services

Liste des services à activer. Les services disponibles comprennent ‘imap’, ‘imap-login’, ‘pop3’, ‘pop3-login’, ‘auth’ et ‘lmtp’.

Les champs de service-configuration disponibles sont :

paramètre de service-configuration : string kind

Le type de service. Les valeurs valides comprennent director, imap-login, pop3-login, lmtp, imap, pop3, auth, auth-worker, dict, tcpwrap, quota-warning ou n’importe quoi d’autre.

paramètre de service-configuration : listener-configuration-list listeners

Les auditeurs du service. Un auditeur est soit un unix-listener-configuration, soit un fifo-listener-configuration, soit un inet-listener-configuration. La valeur par défaut est ‘()’.

Les champs de unix-listener-configuration disponibles sont :

paramètre de unix-listener-configuration : string path

Chemin vers le fichier, relativement au champ base-dir. C’est aussi utilisé comme nom de section.

paramètre de unix-listener-configuration : string mode

Le mode d’accès pour le socket. La valeur par défaut est ‘"0600"’.

paramètre de unix-listener-configuration : string user

L’utilisateur à qui appartient le socket. La valeur par défaut est ‘""

paramètre de unix-listener-configuration : string group

Le groupe auquel appartient le socket. La valeur par défaut est ‘""’.

Les champs de fifo-listener-configuration disponibles sont :

paramètre de fifo-listener-configuration : string path

Chemin vers le fichier, relativement au champ base-dir. C’est aussi utilisé comme nom de section.

paramètre de fifo-listener-configuration : string mode

Le mode d’accès pour le socket. La valeur par défaut est ‘"0600"’.

paramètre de fifo-listener-configuration : string user

L’utilisateur à qui appartient le socket. La valeur par défaut est ‘""

paramètre de fifo-listener-configuration : string group

Le groupe auquel appartient le socket. La valeur par défaut est ‘""’.

Les champs de inet-listener-configuration disponibles sont :

paramètre de inet-listener-configuration : string protocol

Le protocole à écouter.

paramètre de inet-listener-configuration : string address

L’adresse sur laquelle écouter, ou la chaîne vide pour toutes les adresses. La valeur par défaut est ‘""’.

paramètre de inet-listener-configuration : non-negative-integer port

Le port sur lequel écouter.

paramètre de inet-listener-configuration : boolean ssl?

S’il faut utiliser SSL pour ce service ; ‘yes’, ‘no’ ou ‘required’. La valeur par défaut est ‘#t’.

paramètre de service-configuration : non-negative-integer client-limit

Connexions de clients simultanées maximum par processus. Une fois ce nombre de connections atteint, la connexion suivante fera en sorte que Dovecot démarre un autre processus. Si la valeur est 0, default-client-limit est utilisé à la place.

La valeur par défaut est ‘0’.

paramètre de service-configuration : non-negative-integer service-count

Nombre de connexions à gérer avant de démarrer un nouveau processus. Typiquement les valeurs utiles sont 0 (sans limite) ou 1. 1 est plus sûr, mais 0 est plus rapide. <doc/wiki/LoginProcess.txt>. La valeur par défaut est ‘1’.

paramètre de service-configuration : non-negative-integer process-limit

Nombre de processus maximum qui peut exister pour ce service. Si la valeur est 0, default-process-limit est utilisé à la place.

La valeur par défaut est ‘0’.

paramètre de service-configuration : non-negative-integer process-min-avail

Nombre de processus à toujours garder en attente de connexions. La valeur par défaut est ‘0’.

paramètre de service-configuration : non-negative-integer vsz-limit

Si vous mettez ‘service-count 0’, vous avez sans doute besoin d’augmenter ce paramètre. La valeur par défaut est ‘256000000’.

paramètre de dovecot-configuration : dict-configuration dict

Configuration du dictionnaire, créé par le constructeur dict-configuration.

Les champs de dict-configuration disponibles sont :

paramètre de dict-configuration : free-form-fields entries

Une liste de paires de clefs-valeurs que ce dictionnaire contient. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : passdb-configuration-list passdbs

Une liste de configurations passdb, chacune créée par le constructeur passdb-configuration.

Les champs de passdb-configuration disponibles sont :

paramètre de passdb-configuration : string driver

Le pilote à utiliser par passdb. Les valeur valides comprennent ‘pam’, ‘passwd’, ‘shadow’, ‘bsdauth’ et ‘static’. La valeur par défaut est ‘"pam"’.

paramètre de passdb-configuration : space-separated-string-list args

Liste d’arguments pour le pilote passdb séparés par des espaces. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : userdb-configuration-list userdbs

Liste des configurations userdb, chacune créée par le constructeur userdb-configuration.

Les champs de userdb-configuration disponibles sont :

paramètre de userdb-configuration : string driver

Le pilote que userdb devrait utiliser. Les valeurs valides comprennent ‘passwd’ et ‘static’. La valeur par défaut est ‘"passwd"’.

paramètre de userdb-configuration : space-separated-string-list args

Liste des arguments du pilote userdb séparés par des espaces. La valeur par défaut est ‘""’.

paramètre de userdb-configuration : free-form-args override-fields

Remplace des champs de passwd. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : plugin-configuration plugin-configuration

Configuration du greffon, créé par le constructeur plugin-configuration.

paramètre de dovecot-configuration : list-of-namespace-configuration namespaces

Liste d’espaces de noms. Chaque élément de la liste est créé par le constructeur namespace-configuration.

Les champs de namespace-configuration disponibles sont :

paramètre de namespace-configuration : string name

Nom de cet espace de nom.

paramètre de namespace-configuration : string type

Type d’espace de nom : ‘private’, ‘shared’ ou ‘public’. La valeur par défaut est ‘"private"’.

paramètre de namespace-configuration : string separator

Séparateur de hiérarchie à utiliser. Vous devriez utiliser le même séparateur pour tous les espaces de noms ou certains clients seront confus. ‘/’ est généralement une bonne valeur. La valeur par défaut dépend cependant du format de stockage sous-jacent. La valeur par défaut est ‘""’.

paramètre de namespace-configuration : string prefix

Préfixe requis pour accéder à cet espace de nom. Ce paramètres doit être différent pour tous les espaces de noms. Par exemple ‘Public/’. La valeur par défaut est ‘""’.

paramètre de namespace-configuration : string location

Emplacement physique de la boîte aux lettres. C’est le même format que mail_location, qui est aussi la valeur par défaut. La valeur par défaut est ‘""’.

paramètre de namespace-configuration : boolean inbox?

Il ne peut y avoir qu’un INBOX, et ce paramètre définit l’espace de nom qui le possède. La valeur par défaut est ‘#f’.

paramètre de namespace-configuration : boolean hidden?

Si l’espace de nom est caché, il n’est pas publié auprès des clients par l’extension NAMESPACE. Vous voudrez aussi sans doute indiquer ‘list? #f’. C’est surtout utile lors de la conversion depuis un autre serveur avec des espaces de noms différents que vous voulez rendre obsolètes sans les casser. Par exemple vous pouvez cacher les espaces de noms avec les préfixes ‘~/mail/’, ‘~%u/mail/’ et ‘mail/’. La valeur par défaut est ‘#f’.

paramètre de namespace-configuration : boolean list?

Montre les boîtes aux lettres sons cet espace de nom avec la commande LIST. Cela rend l’espace de nom visible pour les clients qui ne supportent pas l’extension NAMESPACE. La valeur spéciale children liste les boîtes aux lettres filles mais cache le préfixe de l’espace de nom. La valeur par défaut est ‘#t’.

paramètre de namespace-configuration : boolean subscriptions?

Les espaces de noms gèrent leur propre souscription. Si la valeur est #f, l’espace de nom parent s’en charge. Le préfixe vide devrait toujours avoir cette valeur à #t. La valeur par défaut est ‘#t’.

paramètre de namespace-configuration : mailbox-configuration-list mailboxes

Liste des boîtes aux lettres prédéfinies dans cet espace de nom. La valeur par défaut est ‘()’.

Les champs de mailbox-configuration disponibles sont :

paramètre de mailbox-configuration : string name

Nom de cette boîte aux lettres.

paramètre de mailbox-configuration : string auto

create’ créera automatiquement cette boîte aux lettres. ‘subscribe’ créera et souscrira à la boîte aux lettres. La valeur par défaut est ‘"no"’.

paramètre de mailbox-configuration : space-separated-string-list special-use

Liste des attributs SPECIAL-USE IMAP spécifiés par la RFC 6154. Les valeurs valides sont \All, \Archive, \Drafts, \Flagged, \Junk, \Sent et \Trash. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : file-name base-dir

Répertoire de base où stocker les données d’exécution. La valeur par défaut est ‘"/var/run/dovecot/"’.

paramètre de dovecot-configuration : string login-greeting

Message d’accueil pour les clients. La valeur par défaut est ‘"Dovecot ready."’.

paramètre de dovecot-configuration : space-separated-string-list login-trusted-networks

Liste des groupes d’adresses de confiance. Les connexions depuis ces IP sont autorisées à modifier leurs adresses IP et leurs ports (pour la connexion et la vérification d’authentification). ‘disable-plaintext-auth’ est aussi ignoré pour ces réseaux. Typiquement vous voudrez spécifier votre mandataire IMAP ici. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : space-separated-string-list login-access-sockets

Liste des sockets de vérification d’accès de connexion (p. ex. tcpwrap). La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : boolean verbose-proctitle?

Montre des titres de processus plus verbeux (dans ps). Actuellement, montre le nom d’utilisateur et l’adresse IP. Utile pour voir qui utilise en réalité les processus IMAP (p. ex. des boîtes aux lettres partagées ou si le même uid est utilisé pour plusieurs comptes). La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean shutdown-clients?

Indique si les processus devraient toujours être tués lorsque le processus maître de Dovecot est éteint. La valeur #f signifie que Dovecot peut être mis à jour sans forcer les connexions clientes existantes à se fermer (bien que cela puisse être un problème si la mise à jour est un correctif de sécurité par exemple). La valeur par défaut est ‘#t’.

paramètre de dovecot-configuration : non-negative-integer doveadm-worker-count

Si la valeur n’est pas zéro, lance les commandes de courriel via ce nombre de connexions au serveur doveadm au lieu de les lancer dans le même processus. La valeur par défaut est ‘0’.

paramètre de dovecot-configuration : string doveadm-socket-path

Socket UNIX ou hôte:port utilisé pour se connecter au serveur doveadm. La valeur par défaut est ‘"doveadm-server"’.

paramètre de dovecot-configuration : space-separated-string-list import-environment

Liste des variables d’environnement qui sont préservées au démarrage de Dovecot et passées à tous ses processus fils. Vous pouvez aussi donner des paires clef=valeur pour toujours spécifier ce paramètre.

paramètre de dovecot-configuration : boolean disable-plaintext-auth?

Désactive la commande LOGIN et toutes les autres authentifications en texte clair à moins que SSL/TLS ne soit utilisé (capacité LOGINDISABLED). Remarquez que si l’IP distante correspond à l’IP locale (c.-à-d. que vous vous connectez depuis le même ordinateur), la connexion est considérée comme sécurisée et l’authentification en texte clair est permise. Voir aussi le paramètre ssl=required. La valeur par défaut est ‘#t’.

paramètre de dovecot-configuration : non-negative-integer auth-cache-size

Taille du cache d’authentification (p. ex. ‘#e10e6’). 0 signifie qu’il est désactivé. Remarquez que bsdauth, PAM et vpopmail ont besoin que ‘cache-key’ soit indiqué pour que le cache soit utilisé. La valeur par défaut est ‘0’.

paramètre de dovecot-configuration : string auth-cache-ttl

Durée de vie des données en cache. Après l’expiration du TTL l’enregistrement en cache n’est plus utilisé *sauf* si la requête à la base de données principale revoie une erreur interne. Nous essayons aussi de gérer les changements de mot de passe automatiquement : si l’authentification précédente de l’utilisateur était réussie mais pas celle-ci, le cache n’est pas utilisé. Pour l’instant cela fonctionne avec l’authentification en texte clair uniquement. La valeur par défaut est ‘"1 hour"’.

paramètre de dovecot-configuration : string auth-cache-negative-ttl

TTL pour les résultats négatifs (l’utilisateur n’est pas trouvé ou le mot de passe ne correspond pas). 0 désactive la mise en cache complètement. La valeur par défaut est ‘"1 hour"’.

paramètre de dovecot-configuration : space-separated-string-list auth-realms

Liste des domaines pour les mécanismes d’authentification SASL qui en ont besoin. Vous pouvez laisser ce paramètre vide si vous ne voulez pas utiliser plusieurs domaines. Beaucoup de clients utilisent le premier domaine listé ici, donc gardez celui par défaut en premier. La valeur par défaut est ‘()

paramètre de dovecot-configuration : string auth-default-realm

Domaine par défaut à utiliser si aucun n’est spécifié. C’est utilisé pour les domaines SASL et pour ajouter @domaine au nom d’utilisateur dans les authentification en texte clair. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string auth-username-chars

Liste des caractères autorisés dans les noms d’utilisateur. Si le nom d’utilisateur donné par l’utilisateur contient un caractère qui n’est pas listé ici, la connexion échoue automatiquement. C’est juste une vérification supplémentaire pour s’assure que l’utilisateur ne puisse pas exploiter des vulnérabilités potentielles d’échappement de guillemets avec les bases de données SQL/LDAP. Si vous voulez autoriser tous les caractères, indiquez la liste vide.

paramètre de dovecot-configuration : string auth-username-translation

Traduction de caractères dans les noms d’utilisateur avant qu’ils ne soient cherchés en base. La valeur contient une série de caractère de -> à. Par exemple ‘#@/@’ signifie que ‘#’ et ‘/’ sont traduits en ‘@’. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string auth-username-format

Format des noms d’utilisateur avant qu’ils ne soient cherchés en base. Vous pouvez utiliser les variables standard ici, p. ex. %Lu est le nom d’utilisateur en minuscule, %n enlève le domaine s’il est donné ou ‘%n-AT-%d’ changerait le ‘@’ en ‘-AT-’. Cette traduction est faite après les changements de ‘auth-username-translation’. La valeur par défaut est ‘"%Lu"’.

paramètre de dovecot-configuration : string auth-master-user-separator

Si vous voulez permettre aux utilisateurs maîtres de se connecter en spécifiant le nom d’utilisateur maître dans la chaîne de nom d’utilisateur normal (c.-à-d. sans utiliser le support du mécanisme SASL pour cela), vous pouvez spécifier le caractère de séparation ici. Le format est ensuite <nom d’utilisateur><séparateur><nom d’utilisateur maître>. UW-IMAP utilise ‘*’ comme séparateur, donc ça pourrait être un bon choix. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string auth-anonymous-username

Nom d’utilisateur à utiliser pour les utilisateurs qui se connectent avec le mécanisme SASL ANONYMOUS. La valeur par défaut est ‘"anonymous"’.

paramètre de dovecot-configuration : non-negative-integer auth-worker-max-count

Nombre maximum de processus de travail dovecot-auth. Ils sont utilisés pour exécuter des requêtes passdb et userdb bloquantes (p. ex. MySQL et PAM). Ils sont créés automatiquement et détruits au besoin. La valeur par défaut est ‘30’.

paramètre de dovecot-configuration : string auth-gssapi-hostname

Nom d’hôte à utiliser dans les noms GSSAPI principaux. La valeur par défaut est d’utiliser le nom renvoyé par gethostname(). Utilisez ‘$ALL’ (avec des guillemets) pour permettre toutes les entrées keytab. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string auth-krb5-keytab

Keytab Kerberos à utiliser pour le mécanisme GSSAPI. Utilisera la valeur par défaut du système (typiquement /etc/krb5.keytab) s’il n’est pas spécifié. Vous pourriez avoir besoin de faire en sorte que le service d’authentification tourne en root pour pouvoir lire ce fichier. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : boolean auth-use-winbind?

Effectue l’authentification NTLM et GSS-SPNEGO avec le démon winbind de Samba et l’utilitaire ‘ntlm-auth’. <doc/wiki/Authentication/Mechanisms/Winbind.txt>. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : file-name auth-winbind-helper-path

Chemin du binaire ‘ntlm-auth’ de samba. La valeur par défaut est ‘"/usr/bin/ntlm_auth"’.

paramètre de dovecot-configuration : string auth-failure-delay

Durée d’attente avant de répondre à des authentifications échouées. La valeur par défaut est ‘"2 secs"’.

paramètre de dovecot-configuration : boolean auth-ssl-require-client-cert?

Requiert un certification client SSL valide ou l’authentification échoue. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean auth-ssl-username-from-cert?

Prend le nom d’utilisateur du certificat SSL client, avec X509_NAME_get_text_by_NID() qui renvoie le CommonName du DN du sujet. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : space-separated-string-list auth-mechanisms

Liste des mécanismes d’authentification souhaités. Les mécanismes supportés sont : ‘plain’, ‘login’, ‘digest-md5’, ‘cram-md5’, ‘ntlm’, ‘rpa’, ‘apop’, ‘anonymous’, ‘gssapi’, ‘otp’, ‘skey’ et ‘gss-spnego’. Remarquez : Voir aussi le paramètre ‘disable-plaintext-auth’.

paramètre de dovecot-configuration : space-separated-string-list director-servers

Liste des IP ou des noms d’hôtes des serveurs directeurs, dont soi-même. Les ports peuvent être spécifiés avec ip:port. Le port par défaut est le même que le ‘inet-listener’ du service directeur. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : space-separated-string-list director-mail-servers

Liste des IP ou des noms d’hôtes de tous les serveurs de courriel de la grappe. Les intervalles sont aussi permis, comme 10.0.0.10-10.0.0.30. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : string director-user-expire

Combien de temps avant de rediriger les utilisateurs à un serveur spécifique après qu’il n’y a plus de connexion. La valeur par défaut est ‘"15 min"’.

paramètre de dovecot-configuration : string director-username-hash

La manière de traduire le nom d’utilisateur avant de le hasher. Les valeurs utiles comprennent %Ln si l’utilisateur peut se connecter avec ou sans @domain, %Ld si les boîtes aux lettres sont partagées dans le domaine. La valeur par défaut est ‘"%Lu"’.

paramètre de dovecot-configuration : string log-path

Fichier de journal à utiliser pour les messages d’erreur. ‘syslog’ journalise vers syslog, ‘/dev/stderr’ vers la sortie d’erreur. La valeur par défaut est ‘"syslog"’.

paramètre de dovecot-configuration : string info-log-path

Fichier de journal à utiliser pour les messages d’information. La valeur par défaut est ‘log-path’. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string debug-log-path

Fichier de journal à utiliser pour les messages de débogage. La valeur par défaut est ‘info-log-path’. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string syslog-facility

Dispositif syslog à utiliser si vous journalisez avec syslog. Normalement si vous ne voulez pas utiliser ‘mail’, vous voudrez utiliser local0..local7. D’autres dispositifs standard sont supportés. La valeur par défaut est ‘"mail"’.

paramètre de dovecot-configuration : boolean auth-verbose?

Indique s’il faut enregistrer les tentatives de connexion échouées et la raison de leur échec. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : string auth-verbose-passwords

Dans le cas où le mot de passe n’était pas correct, indique s’il faut enregistrer le mauvais mot de passe. Les valeurs valides sont « no », « plain » et « sha1 ». Il peut être utile d’indiquer « sha1 » pour discriminer des attaques par force brute d’utilisateurs qui réessayent encore et encore le même mot de passe. Vous pouvez aussi tronquer la valeur à n caractères en ajoutant « :n » (p. ex. « sha1:6 »). La valeur par défaut est ‘"no"’.

paramètre de dovecot-configuration : boolean auth-debug?

Journaux encore plus verbeux pour le débogage. Cela montre par exemple les requêtes SQL effectuées. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean auth-debug-passwords?

Dans le cas où le mot de passe était incorrect, indique s’il faut enregistrer les mots de passe et les schémas utilisés pour que le problème puisse être débogué. Activer cette option active aussi ‘auth-debug’. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean mail-debug?

Indique s’il faut activer le débogage du traitement des courriels. Cela peut vous aider à comprendre pourquoi Dovecot ne trouve pas vos courriels. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean verbose-ssl?

Indique s’il faut montrer les erreurs au niveau SSL. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : string log-timestamp

Préfixe à utiliser devant chaque ligne écrite dans le fichier journal. Les codes % sont au format strftime(3). La valeur par défaut est ‘"\"%b %d %H:%M:%S \""’.

paramètre de dovecot-configuration : space-separated-string-list login-log-format-elements

Liste des éléments qu’il faut enregistrer. Les éléments qui ont une variable non vide sont agrégés pour former une chaîne de mots séparés par des virgules.

paramètre de dovecot-configuration : string login-log-format

Format du journal de connexion. %s contient la chaîne ‘login-log-format-elements’, %$ contient la donnée à enregistrer. La valeur par défaut est ‘"%$: %s"’.

paramètre de dovecot-configuration : string mail-log-prefix

Préfixe à utiliser devant chaque ligne du fichier de journal pour les processus traitant les courriels. Voir doc/wiki/Variables.txt pour trouver la liste des variables que vous pouvez utiliser. La valeur par défaut est ‘"\"%s(%u)<%{pid}><%{session}>: \""’.

paramètre de dovecot-configuration : string deliver-log-format

Format à utiliser pour enregistrer les livraisons de courriels. Vous pouvez utiliser ces variables :

%$

Message de statut de la livraison (p. ex. ‘saved to INBOX’)

%m

Message-ID

%s

Objet

%f

Adresse « de »

%p

Taille physique

%w

Taille virtuelle.

La valeur par défaut est ‘"msgid=%m: %$"’.

paramètre de dovecot-configuration : string mail-location

Emplacement des boîtes à lettre des utilisateurs. La valeur par défaut est vide, ce qui signifie que Dovecot essaiera de trouver les boîte aux lettres automatiquement. Cela ne fonctionnera pas si l’utilisateur n’a aucun courriel, donc il vaut mieux indiquer explicitement le bon emplacement à Dovecot.

Si vous utilisez mbox, il ne suffit pas de donner le chemin vers le fichier INBOX (p. ex. /var/mail/%u). Vous devrez aussi dire à Dovecot où les autres boîtes aux lettres se trouvent. Cela s’appelle le « répertoire racine des courriels » et il doit être le premier chemin donné à l’option ‘mail-location’.

Il y a quelques variables spéciales que vous pouvez utiliser :

%u

nom d’utilisateur

%n

la partie « utilisateur » dans « utilisateur@domaine », comme %u s’il n’y a pas de domaine

%d

la partie « domaine » dans « utilisateur@domaine », vide s’il n’y a pas de domaine

%h

répertoire personnel

Voir doc/wiki/Variables.txt pour la liste complète. Quelques exemple :

maildir:~/Maildir
mbox:~/mail:INBOX=/var/mail/%u
mbox:/var/mail/%d/%1n/%n:INDEX=/var/indexes/%d/%1n/%

La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string mail-uid

Utilisateur et groupe système utilisé pour accéder aux courriels. Si vous utilisez multiple, userdb peut remplacer ces valeurs en renvoyant les champs uid et gid. Vous pouvez utiliser soit des nombres, soit des noms. <doc/wiki/UserIds.txt>. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string mail-gid

La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string mail-privileged-group

Groupe à activer temporairement pour les opérations privilégiées. Actuellement cela est utilisé uniquement avec INBOX lors de sa création initiale et quand le verrouillage échoie. Typiquement, vous pouvez utiliser « mail » pour donner accès à /var/mail. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : string mail-access-groups

Donne l’accès à ces groupes supplémentaires aux processus de courriel. Ils sont typiquement utilisés pour mettre en place l’accès à des boîtes aux lettres partagées. Remarquez qu’il peut être dangereux d’utiliser cette option si l’utilisateur peut créer des liens symboliques (p. ex. si le groupe « mail » est utilisé ici, « ln -s /var/mail ~/mail/var » peut permettre à un utilisateur de supprimer les boîtes aux lettres des autres, ou « ln -s /secret/shared/box ~/mail/mybox » lui permettrait de la lire). La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : boolean mail-full-filesystem-access?

Permet l’accès complet au système de fichiers pour les clients. Il n’y a pas de vérification d’accès autres que ce que le système d’exploitation fait avec les UID/GID. Cela fonctionne aussi bien avec maildir qu’avec mbox, ce qui vous permet de préfixer les noms des boîtes aux lettres avec p. ex. /chemin/ ou ~utilisateur/. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean mmap-disable?

Ne pas du tout utiliser mmap(). Cela est requis si vous stockez les index dans des systèmes de fichiers partagés (NFS ou clusterfs). La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean dotlock-use-excl?

S’appuyer sur ‘O_EXCL’ lors de la création de fichiers de verrouillage. NFS supporte ‘O_EXCL’ depuis la version 3, donc cette option est sûre de nos jours. La valeur par défaut est ‘#t’.

paramètre de dovecot-configuration : string mail-fsync

Quand utiliser les appels à fsync() ou fdatasync() :

optimized

Lorsque cela est nécessaire pour éviter de perdre des données importantes

always

Utile lorsque par exemple les écritures NFS sont retardées

never

Ne l’utilisez pas (ça a de meilleures performances, mais les crashs font perdre toutes les données).

La valeur par défaut est ‘"optimized"’.

paramètre de dovecot-configuration : boolean mail-nfs-storage?

Le stockage des courriels se fait sur NFS. Utilisez cette option pour que Dovecot vide les caches NFS lorsque c’est nécessaire. Si vous utilisez seulement un simple serveur de courriel, ce n’est pas nécessaire. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean mail-nfs-index?

Les fichiers d’index de courriels sont sur un système de fichiers NFS. Pour utiliser cette option, vous aurez besoin de ‘mmap-disable? #t’ et ‘fsync-disable? #f’. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : string lock-method

Méthode de verrouillage des fichiers d’index. Les alternatives sont fcntl, flock et dotlock. Le verrouillage-point (dotlocking) utilise des astuces qui peuvent créer plus d’utilisation du disque que les autres méthodes de verrouillage. Pour les utilisateurs de NFS, flock ne marche pas, et rappelez-vous de modifier ‘mmap-disable’. La valeur par défaut est ‘"fcntl"’.

paramètre de dovecot-configuration : file-name mail-temp-dir

Le répertoire dans lequel LDA/LMTP stockent temporairement les courriels de plus de 128 Ko. La valeur par défaut est ‘"/tmp"’.

paramètre de dovecot-configuration : non-negative-integer first-valid-uid

L’intervalle d’UID valides pour les utilisateurs. Cette option est surtout utile pour s’assurer que les utilisateurs ne peuvent pas s’authentifier en tant que démon ou qu’un autre utilisateur système. Remarquez que la connexion en root est interdite en dur dans le binaire de dovecot et qu’on ne peut pas l’autoriser même si ‘first-valid-uid’ vaut 0. La valeur par défaut est ‘500’.

paramètre de dovecot-configuration : non-negative-integer last-valid-uid

La valeur par défaut est ‘0’.

paramètre de dovecot-configuration : non-negative-integer first-valid-gid

Li’ntervalle de GID valides pour les utilisateurs. Les utilisateurs qui ont un GID non-valide comme numéro de groupe primaire ne peuvent pas se connecter. Si l’utilisateur appartient à un groupe avec un GID non valide, ce groupe n’est pas utilisable. La valeur par défaut est ‘1’.

paramètre de dovecot-configuration : non-negative-integer last-valid-gid

La valeur par défaut est ‘0’.

paramètre de dovecot-configuration : non-negative-integer mail-max-keyword-length

Longueur maximale autorisée pour les mots-clefs. Elle n’est utilisée que lors de la création de nouveaux mots-clefs. La valeur par défaut est ‘50’.

paramètre de dovecot-configuration : colon-separated-file-name-list valid-chroot-dirs

Liste des répertoires sous lesquels le chroot est permis pour les processus de traitement des courriels (c.-à-d. /var/mail permettra aussi de se chrooter dans /var/mail/foo/bar). Ce paramètre n’affecte pas ‘login-chroot’ ‘mail-chroot’ ou les paramètres de chroot de l’authentification. Si ce paramètre est vide, « /./ » dans les répertoires personnels sont ignorés. ATTENTION : n’ajoutez jamais de répertoires ici que les utilisateurs locaux peuvent modifier, puisque ça pourrait permettre d’escalader les privilèges. Normalement vous ne devriez le faire que si les utilisateurs n’ont pas d’accès shell. <doc/wiki/Chrooting.txt>. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : string mail-chroot

Répertoire chroot par défaut pour les processus de traitement des courriels. Cela peut être modifié pour des utilisateurs particuliers dans la base de donnée en donnant /./ dans le répertoire personnel (p. ex. /home/./utilisateur permet de se chrooter dans /home). Remarquez qu’il n’y a d’habitude pas besoin de se chrooter. Dovecot ne permet pas aux utilisateurs d’accéder aux fichiers en dehors de leur répertoire de courriels de toute façon. Si vos répertoires personnels sont préfixés par le répertoire de chroot, ajoutez « /. » à ‘mail-chroot’. <doc/wiki/Chrooting.txt>. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : file-name auth-socket-path

Chemin de socket UNIX vers le serveur d’authentification maître pour trouver les utilisateurs. C’est utilisé par imap (pour les utilisateurs partagés) et lda. La valeur par défaut est ‘"/var/run/dovecot/auth-userdb"’.

paramètre de dovecot-configuration : file-name mail-plugin-dir

Répertoire où trouver les greffons. La valeur par défaut est ‘"/usr/lib/dovecot"’.

paramètre de dovecot-configuration : space-separated-string-list mail-plugins

Liste des greffons à charger pour tous les services. Les greffons spécifiques à IMAP, LDA, etc. sont ajoutés à cette liste dans leur propre fichiers .conf. La valeur par défaut est ‘()’.

paramètre de dovecot-configuration : non-negative-integer mail-cache-min-mail-count

Le nombre minimal de courriels dans une boîte aux lettres avant de mettre à jour le fichier de cache. Cela permet d’optimiser le comportement de Dovecot pour qu’il fasse moins d’écriture disque contre plus de lecture disque. La valeur par défaut est ‘0’.

paramètre de dovecot-configuration : string mailbox-idle-check-interval

Lorsque la commande IDLE est lancée, la boîte aux lettres est vérifiée de temps en temps pour voir s’il y a de nouveaux messages ou d’autres changements. Ce paramètre défini le temps d’attente minimum entre deux vérifications. Dovecot peut aussi utilise dnotify, inotify et kqueue pour trouver immédiatement les changements. La valeur par défaut est ‘"30 secs"’.

paramètre de dovecot-configuration : boolean mail-save-crlf?

Sauvegarder les courriels avec CR+LF plutôt que seulement LF. Cela permet de consommer moins de CPU en envoyant ces courriels, surtout avec l’appel système sendfile() de Linux et FreeBSD. Mais cela crée un peu plus d’utilisation du disque, ce qui peut aussi le ralentir. Remarquez aussi que si d’autres logiciels lisent les mbox/maildirs, ils peuvent se tromper dans leur traitement de ces CR supplémentaires et causer des problèmes. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean maildir-stat-dirs?

Par défaut la commande LIST renvoie toutes les entrées du maildir qui commencent par un point. Activer cette option permet à Dovecot de renvoyer uniquement les entrées qui sont des répertoires. Cela se fait avec stat() sur chaque entrée, ce qui cause plus d’utilisation du disque. For systems setting struct ‘dirent->d_type’ this check is free and it’s done always regardless of this setting). La valeur par défaut est ‘#f’.

Lors de la copie d’un message, le faire avec des liens en dur si possible. Cela améliore un peu la performance et n’a que peu de chance d’avoir des effets secondaires.

paramètre de dovecot-configuration : boolean maildir-very-dirty-syncs?

Suppose que Dovecot est le seul MUA qui accède à Maildir : scanne le répertoire cur/ seulement lorsque son mtime change de manière inattendue ou lorsqu’il ne peut pas trouver le courriel autrement. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : space-separated-string-list mbox-read-locks

La méthode de verrouillage à utiliser pour verrouiller le boîtes aux lettres mbox. Il y en a quatre :

dotlock

Crée un fichier <mailbox>.lock. C’est la solution la plus ancienne et la plus sûr pour NFS. Si vous voulez utiliser /var/mail/, les utilisateurs auront besoin de l’accès en écriture à ce répertoire.

dotlock-try

Comme pour dotlock, mais si elle échoue à cause d’un problème de permission ou parce qu’il n’y a pas assez d’espace disque, l’ignore.

fcntl

Utilisez cette méthode si possible. Elle fonctionne aussi avec NFS si vous utilisez lockd.

flock

Peut ne pas exister sur tous les systèmes. Ne fonctionne pas avec NFS.

lockf

Peut ne pas exister sur tous les systèmes. Ne fonctionne pas avec NFS.

Vous pouvez utiliser plusieurs méthodes de verrouillage ; dans ce cas l’ordre dans lequel elles sont déclarées est important pour éviter des interblocages si d’autres MTA/MUA utilisent aussi plusieurs méthodes. Certains systèmes d’exploitation ne permettent pas d’utiliser certaines méthodes en même temps.

paramètre de dovecot-configuration : space-separated-string-list mbox-write-locks
paramètre de dovecot-configuration : string mbox-lock-timeout

Temps d’attente maximal pour un verrou (tous les verrous) avant d’abandonner. La valeur par défaut est ‘"5 mins"’.

paramètre de dovecot-configuration : string mbox-dotlock-change-timeout

Si le fichier dotlock existe mais que la boîte aux lettres n’est pas modifiée, remplacer le fichier de verrouillage après ce temps d’attente. La valeur par défaut est ‘"2 mins"’.

paramètre de dovecot-configuration : boolean mbox-dirty-syncs?

Lorsqu’un mbox change ne manière inattendue, il faut le lire en entier pour savoir ce qui a changé. Si le mbox est assez grand cela peut prendre beaucoup de temps. Comme le changement est habituellement un simple courriel supplémentaire, il serait plus rapide de lire le nouveaux courriels. Si ce paramètre est activé, Dovecot fait cela mais revient toujours à relire le fichier mbox complet si le fichier n’est pas comme attendu. Le seul réel inconvénient à ce paramètre est que certains MUA changent les drapeaux des messages, et dans ce cas Dovecot ne s’en rend pas immédiatement compte. Remarquez qu’une synchronisation complète est effectuée avec les commandes SELECT, EXAMINE, EXPUNGE et CHECK. La valeur par défaut est ‘#t’.

paramètre de dovecot-configuration : boolean mbox-very-dirty-syncs?

Comme ‘mbox-dirty-syncs’, mais ne synchronise pas complètement même avec les commandes SELECT, EXAMINE, EXPUNGE ou CHECK. Si l’option n’est pas activée, ‘mbox-dirty-syncs’ est ignorée. La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : boolean mbox-lazy-writes?

Attendre avant d’écrire les en-têtes mbox jusqu’à la prochaine synchronisation des écritures (les commandes EXPUNGE et CHECK et quand on ferme la boîte aux lettres). C’est surtout utile pour POP3 où les clients suppriment souvent tous les courriels. L’inconvénient c’est que vos changements ne sont pas immédiatement visibles pour les autres MUA. La valeur par défaut est ‘#t’.

paramètre de dovecot-configuration : non-negative-integer mbox-min-index-size

Si la taille du fichier mbox est plus petite que cela (p. ex. 100k), ne pas écrire de fichier d’index. Si un fichier d’index existe déjà il est toujours lu, mais pas mis à jour. La valeur par défaut est ‘0’.

paramètre de dovecot-configuration : non-negative-integer mdbox-rotate-size

Taille du fichier dbox maximale avant rotation. La valeur par défaut est ‘10000000’.

paramètre de dovecot-configuration : string mdbox-rotate-interval

Âge maximum du fichier dbox avant rotation. Typiquement en jours. Les jours commencent à minuit, donc 1d signifie aujourd’hui, 2d pour hier, etc. 0 pour désactiver la vérification. La valeur par défaut est ‘"1d"’.

paramètre de dovecot-configuration : boolean mdbox-preallocate-space?

Lors de la création des fichiers mdbox, préallouer immédiatement leur taille à ‘mdbox-rotate-size’. Ce paramètre ne fonctionne actuellement que dans Linux avec certains systèmes de fichiers (ext4, xfs). La valeur par défaut est ‘#f’.

paramètre de dovecot-configuration : string mail-attachment-dir

Les formats sdbox et mdbox supportent la sauvegarde des pièces-jointes dans des fichiers externes, ce qui permet de les stocker une seule fois. Les autres moteurs ne le supportent pas pour le moment.

ATTENTION : Cette fonctionnalité n’a pas été beaucoup testée. Utilisez-la à vos risques et périls.

Racine du répertoire où stocker les pièces-jointes. Désactivé si vide. La valeur par défaut est ‘""’.

paramètre de dovecot-configuration : non-negative-integer mail-attachment-min-size

Les pièces-jointes plus petites que cela ne sont pas enregistrées à part. Il est aussi possible d’écrire un greffon pour désactiver l’enregistrement externe de certaines pièces-jointes spécifiques. La valeur par défaut est ‘128000’.

paramètre de dovecot-configuration : string mail-attachment-fs

Moteur du système de fichier à utiliser pour sauvegarder les pièces-jointes :

posix

Pas de SiS (single instance storage) par Dovecot (mais cela peut aider la déduplication du système de fichier)

sis posix

SiS avec comparaison bit-à-bit immédiate pendant la sauvegarde

sis-queue posix

SiS avec déduplication et comparaison différées.

La valeur par défaut est ‘"sis posix"’.

paramètre de dovecot-configuration : string mail-attachment-hash

Format de hash à utiliser dans les noms de fichiers des pièces-jointes. Vous pouvez ajouter n’importe quel texte ou variable : %{md4}, %{md5}, %{sha1}, %{sha256}, %{sha512}, %{size}. Les variables peuvent être tronquées, p. ex. %{sha256:80} renvoie seulement les 80 premiers bits. La valeur par défaut est ‘"%{sha1}"’.

paramètre de dovecot-configuration : non-negative-integer default-process-limit

La valeur par défaut est ‘100’.

paramètre de dovecot-configuration : non-negative-integer<