diff options
Diffstat (limited to 'doc')
| -rw-r--r-- | doc/guix.fr.texi | 4270 | ||||
| -rw-r--r-- | doc/guix.texi | 74 |
2 files changed, 2441 insertions, 1903 deletions
diff --git a/doc/guix.fr.texi b/doc/guix.fr.texi index 8eda0087e9..6dc7f90555 100644 --- a/doc/guix.fr.texi +++ b/doc/guix.fr.texi @@ -30,12 +30,12 @@ Leo Famulari@* Copyright @copyright{} 2015, 2016, 2017, 2018 Ricardo Wurmus@* Copyright @copyright{} 2016 Ben Woodcroft@* Copyright @copyright{} 2016, 2017, 2018 Chris Marusich@* Copyright @copyright{} 2016, 2017, 2018 Efraim Flashner@* Copyright @copyright{} 2016 John Darrington@* Copyright -@copyright{} 2016, 2017 Nils Gillmann@* Copyright @copyright{} 2016, 2017 -Jan Nieuwenhuizen@* Copyright @copyright{} 2016 Julien Lepiller@* Copyright -@copyright{} 2016 Alex ter Weele@* Copyright @copyright{} 2017, 2018 Clément -Lassieur@* Copyright @copyright{} 2017 Mathieu Othacehe@* Copyright -@copyright{} 2017 Federico Beffa@* Copyright @copyright{} 2017 Carlo -Zancanaro@* Copyright @copyright{} 2017 Thomas Danckaert@* Copyright +@copyright{} 2016, 2017 Nils Gillmann@* Copyright @copyright{} 2016, 2017, +2018 Jan Nieuwenhuizen@* Copyright @copyright{} 2016 Julien Lepiller@* +Copyright @copyright{} 2016 Alex ter Weele@* Copyright @copyright{} 2017, +2018 Clément Lassieur@* Copyright @copyright{} 2017 Mathieu Othacehe@* +Copyright @copyright{} 2017 Federico Beffa@* Copyright @copyright{} 2017 +Carlo Zancanaro@* Copyright @copyright{} 2017 Thomas Danckaert@* Copyright @copyright{} 2017 humanitiesNerd@* Copyright @copyright{} 2017 Christopher Allan Webber@* Copyright @copyright{} 2017, 2018 Marius Bakke@* Copyright @copyright{} 2017 Hartmut Goebel@* Copyright @copyright{} 2017 Maxim @@ -44,7 +44,8 @@ Copyright @copyright{} 2017 George Clemmer@* Copyright @copyright{} 2017 Andy Wingo@* Copyright @copyright{} 2017, 2018 Arun Isaac@* Copyright @copyright{} 2017 nee@* Copyright @copyright{} 2018 Rutger Helling@* Copyright @copyright{} 2018 Oleg Pykhalov@* Copyright @copyright{} 2018 Mike -Gerwitz@* Copyright @copyright{} 2018 Pierre-Antoine Rouby +Gerwitz@* Copyright @copyright{} 2018 Pierre-Antoine Rouby@* Copyright +@copyright{} 2018 Gábor Boskovits@* Vous avez la permission de copier, distribuer ou modifier ce document sous les termes de la Licence GNU Free Documentation, version 1.3 ou toute @@ -100,6 +101,15 @@ Documentation License ». Cette documentation décrit GNU Guix version @value{VERSION}, un outil de gestion de paquets fonctionnel écrit pour le système GNU@. +@c TRANSLATORS: You can replace the following paragraph with information on +@c how to join your own translation team and how to report issues with the +@c translation. +This manual is also available in French (@pxref{Top,,, guix.fr, Manuel de +référence de GNU Guix}). If you would like to translate it in your native +language, consider joining the +@uref{https://translationproject.org/domain/guix-manual.html, Translation +Project}. + @menu * Introduction:: Qu'est-ce que Guix ? * Installation:: Installer Guix. @@ -184,6 +194,7 @@ Interface de programmation * La monad du dépôt:: Interface purement fonctionnelle avec le dépôt. * G-Expressions:: Manipuler les expressions de construction. +* Invoking guix repl:: Fiddling with Guix interactively. Définition des paquets @@ -307,7 +318,7 @@ Services * Services VPN:: Démons VPN * Système de fichiers en réseau:: Services liés à NFS@. * Intégration continue:: Le service Cuirass. -* Services de gestion de l'énergie:: L'outil TLP@. +* Power Management Services:: Extending battery life. * Services audio:: MPD@. * Services de virtualisation:: Services de virtualisation. * Services de contrôle de version:: Fournit des accès distants à des @@ -497,18 +508,18 @@ L'installation se comme ceci : @enumerate @item @cindex téléchargement du Guix binaire -Téléchargez l'archive binaire depuis -@indicateurl{ftp://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{système}.tar.xz}, -où @var{système} est @code{x86_64-linux} pour une machine @code{x86_64} sur -laquelle tourne déjà le noyau Linux, etc. +Download the binary tarball from +@indicateurl{https://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{system}.tar.xz}, +where @var{system} is @code{x86_64-linux} for an @code{x86_64} machine +already running the kernel Linux, and so on. @c The following is somewhat duplicated in ``System Installation''. Assurez-vous de télécharger le fichier @file{.sig} associé et de vérifier l'authenticité de l'archive avec, comme ceci : @example -$ wget ftp://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{système}.tar.xz.sig -$ gpg --verify guix-binary-@value{VERSION}.@var{système}.tar.xz.sig +$ wget https://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{system}.tar.xz.sig +$ gpg --verify guix-binary-@value{VERSION}.@var{system}.tar.xz.sig @end example Si cette commande échoue parce que vous n'avez pas la clef publique requise, @@ -695,8 +706,8 @@ ultérieure, dont 2.2.x, (@pxref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}), @item -@c FIXME: Specify a version number once a release has been made. -@uref{https://notabug.org/civodul/guile-sqlite3, Guile-SQLite3} ; +@uref{https://notabug.org/civodul/guile-sqlite3, Guile-SQLite3}, version +0.1.0 or later; @item @c FIXME: Specify a version number once a release has been made. @uref{https://gitlab.com/guile-git/guile-git, Guile-Git}, d'août 2017 ou @@ -1081,8 +1092,8 @@ Il y a un certain nombre de champs facultatifs que vous pouvez remplir : Numéro de port du serveur SSH sur la machine. @item @code{private-key} (par défaut : @file{~root/.ssh/id_rsa}) -Le fichier de clef privée à utiliser lors de la connexion à la machine, au -format OpenSSH@. +The SSH private key file to use when connecting to the machine, in OpenSSH +format. This key must not be protected with a passphrase. Remarquez que la valeur par défaut est la clef privée @emph{du compte root}. Assurez-vous qu'elle existe si vous utilisez la valeur par défaut. @@ -1469,11 +1480,10 @@ utilisées. @cindex racines du GC @cindex racines du ramasse-miettes -Lorsqu'elle est à « yes », le GC gardera les sorties de toutes les -dérivations — les fichiers @code{.drv} — utilisées 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 s'il s'agit de racines du GC@. @xref{Invoquer guix gc} -pour plus d'informations sur les racines du GC@. +When set to ``yes'', the GC will keep the outputs of any live derivation +available in the store---the @code{.drv} files. The default is ``no'', +meaning that derivation outputs are kept only if they are reachable from a +GC root. @xref{Invoquer guix gc}, for more on GC roots. @item --gc-keep-derivations[=yes|no] Dire si le ramasse-miettes (GC) doit garder les dérivations correspondant à @@ -1485,12 +1495,14 @@ leurs sorties est utilisée. Cela permet aux utilisateurs de garder une trace de l'origine des éléments du dépôt. Le mettre à « no » préserve un peu d'espace disque. -Remarquez qu'avec @code{--gc-keep-derivations} et @code{--gc-keep-outputs}, -le GC gardera tous les prérequis de construction (les sources, le -compilateur, les bibliothèques, et les autres outils de construction) des -objets utilisés dans le dépôt, indépendamment du fait qu'ils soient ou non -utilisés. Cela est pratique pour les développeurs car ça leur fait gagner -du temps de reconstruction et de téléchargement. +In this way, setting @code{--gc-keep-derivations} to ``yes'' causes liveness +to flow from outputs to derivations, and setting @code{--gc-keep-outputs} to +``yes'' causes liveness to flow from derivations to outputs. When both are +set to ``yes'', the effect is to keep all the build prerequisites (the +sources, compiler, libraries, and other build-time tools) of live objects in +the store, regardless of whether these prerequisites are reachable from a GC +root. This is convenient for developers since it saves rebuilds or +downloads. @item --impersonate-linux-2.6 Sur les système basés sur Linux, se faire passer pour Linux 2.6. Cela @@ -2562,7 +2574,7 @@ 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 @code{--fallback} a été passé en -argument (@pxref{fallback-option,, common build option @code{--fallback}}). +argument (@pxref{option de repli,, common build option @code{--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 @code{--fallback} est passé en argument, @@ -2603,7 +2615,7 @@ développeurs à trouver les constructions de paquets non-déterministes (@pxref{Invoquer guix challenge}). De même, l'option @option{--check} de @command{guix build} permet aux utilisateurs de vérifier si les substituts précédemment installés sont authentiques en les reconstruisant localement -(@pxref{build-check, @command{guix build --check}}). +(@pxref{vérification de la construction, @command{guix build --check}}). Dans le futur, nous aimerions que Guix puisse publier et recevoir des binaires d'autres utilisateurs, d'une manière pair-à-pair. Si vous voulez @@ -2907,17 +2919,23 @@ Génération 1 10 juin 2018 00:18:18 branche : origin/master commit : 65956ad3526ba09e1f7a40722c96c6ef7c0936fe -Génération 2 11 juin 2018 11:02:49 +Generation 2 Jun 11 2018 11:02:49 guix e0cc7f6 - URL du dépôt : https://git.savannah.gnu.org/git/guix.git - branche : origin/master - commit : e0cc7f669bec22c37481dd03a7941c7d11a64f1d - -Génération 3 13 juin 2018 23:31:07 (actuelle) + repository URL: https://git.savannah.gnu.org/git/guix.git + branch: origin/master + commit: e0cc7f669bec22c37481dd03a7941c7d11a64f1d + 2 new packages: keepalived, libnfnetlink + 6 packages upgraded: 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 + +Generation 3 Jun 13 2018 23:31:07 (current) guix 844cc1c - URL du dépôt : https://git.savannah.gnu.org/git/guix.git - branche : origin/master - commit : 844cc1c8f394f03b404c5bb3aee086922373490c + repository URL: https://git.savannah.gnu.org/git/guix.git + branch: origin/master + commit: 844cc1c8f394f03b404c5bb3aee086922373490c + 28 new packages: emacs-helm-ls-git, emacs-helm-mu, @dots{} + 69 packages upgraded: borg@@1.1.6, cheese@@3.28.0, @dots{} @end example Ce profil @code{~/.config/guix/current} fonctionne comme les autres profils @@ -3407,6 +3425,7 @@ paquets à haut-niveau. * La monad du dépôt:: Interface purement fonctionnelle avec le dépôt. * G-Expressions:: Manipuler les expressions de construction. +* Invoking guix repl:: Fiddling with Guix interactively. @end menu @node Définition des paquets @@ -4199,6 +4218,21 @@ construction. Le paquet @code{glib} qui fournit Ces deux phases sont exécutées après la phase @code{install}. @end defvr +@defvr {Scheme Variable} guile-build-system +This build system is for Guile packages that consist exclusively of Scheme +code and that are so lean that they don't even have a makefile, let alone a +@file{configure} script. It compiles Scheme code using @command{guild +compile} (@pxref{Compilation,,, guile, GNU Guile Reference Manual}) and +installs the @file{.scm} and @file{.go} files in the right place. It also +installs documentation. + +This build system supports cross-compilation by using the @code{--target} +option of @command{guild compile}. + +Packages built with @code{guile-build-system} must provide a Guile package +in their @code{native-inputs} field. +@end defvr + @defvr {Variable Scheme} minify-build-system Cette variable est exportée par @code{(guix build-system minify)}. Elle implémente une procédure de minification pour des paquets JavaScript @@ -4783,45 +4817,50 @@ 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 à @code{gexp->derivation}. Pour plus d'informations, @pxref{G-Expressions}. -Once upon a time, @code{gexp->derivation} did not exist and constructing -derivations with build code written in Scheme was achieved with -@code{build-expression->derivation}, documented below. This procedure is -now deprecated in favor of the much nicer @code{gexp->derivation}. - -@deffn {Scheme Procedure} build-expression->derivation @var{store} @ - @var{name} @var{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] Return a derivation that -executes Scheme expression @var{exp} as a builder for derivation -@var{name}. @var{inputs} must be a list of @code{(name drv-path sub-drv)} -tuples; when @var{sub-drv} is omitted, @code{"out"} is assumed. -@var{modules} is a list of names of Guile modules from the current search -path to be copied in the store, compiled, and made available in the load -path during the execution of @var{exp}---e.g., @code{((guix build utils) -(guix build gnu-build-system))}. - -@var{exp} is evaluated in an environment where @code{%outputs} is bound to a -list of output/path pairs, and where @code{%build-inputs} is bound to a list -of string/output-path pairs made from @var{inputs}. Optionally, -@var{env-vars} is a list of string pairs specifying the name and value of -environment variables visible to the builder. The builder terminates by -passing the result of @var{exp} to @code{exit}; thus, when @var{exp} returns -@code{#f}, the build is considered to have failed. - -@var{exp} is built using @var{guile-for-build} (a derivation). When -@var{guile-for-build} is omitted or is @code{#f}, the value of the -@code{%guile-for-build} fluid is used instead. - -See the @code{derivation} procedure for the meaning of -@var{references-graphs}, @var{allowed-references}, -@var{disallowed-references}, @var{local-build?}, and @var{substitutable?}. +Il fut un temps où @code{gexp->derivation} n'existait pas et où construire +une dérivation donc le code de construction était écrit en Scheme se faisait +avec @code{build-expression->derivation}, documenté plus bas. Cette +procédure est maintenant obsolète, remplacée par @code{gexp->derivation} qui +est meilleure. + +@deffn {Procédure Scheme} build-expression->derivation @var{store} @ + @var{name} @var{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 @var{exp} comme un +constructeur pour la dérivation @var{name}. @var{inputs} doit être une +liste de tuples @code{(name drv-path sub-drv)} ; lorsque @var{sub-drv} est +omis, @code{"out"} est utilisé. @var{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 @var{exp} — p.@: ex.@: @code{((guix build utils) (guix build +gnu-build-system))}. + +@var{exp} est évaluée dans une environnement où @code{%outputs} est lié à +une liste de paires de sortie/chemin, et où @code{%build-inputs} est lié à +une liste de paires de chaînes de caractères et de chemin de sortie +construite à partir de @var{inputs}. Éventuellement, @var{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 @var{exp} à @code{exit} ; ainsi, lorsque +@var{exp} renvoie @code{#f}, la construction est considérée en échec. + +@var{exp} est construite avec @var{guile-for-build} (une dérivation). +Lorsque @var{guile-for-build} est omis où est @code{#f}, la valeur du fluide +@code{%guile-for-build} est utilisée à la place. + +Voir la procédure @code{derivation} pour la signification de +@var{references-graph}, @var{allowed-references}, +@var{disallowed-references}, @var{local-build?} et @var{substitutable?}. @end deffn @noindent -Here's an example of a single-output derivation that creates a directory -containing one file: +Voici un exemple de dérivation à sortie unique qui crée un répertoire avec +un fichier : @lisp (let ((builder '(let ((out (assoc-ref %outputs "out"))) @@ -4840,33 +4879,36 @@ containing one file: @cindex monad -The procedures that operate on the store described in the previous sections -all take an open connection to the build daemon as their first argument. -Although the underlying model is functional, they either have side effects -or depend on the current state of the store. - -The former is inconvenient: the connection to the build daemon has to be -carried around in all those functions, making it impossible to compose -functions that do not take that parameter with functions that do. The -latter can be problematic: since store operations have side effects and/or -depend on external state, they have to be properly sequenced. - -@cindex monadic values -@cindex monadic functions -This is where the @code{(guix monads)} module comes in. This module -provides a framework for working with @dfn{monads}, and a particularly -useful monad for our uses, the @dfn{store monad}. Monads are a construct -that allows two things: associating ``context'' with values (in our case, -the context is the store), and building sequences of computations (here -computations include accesses to the store). Values in a monad---values -that carry this additional context---are called @dfn{monadic values}; -procedures that return such values are called @dfn{monadic procedures}. - -Consider this ``normal'' procedure: +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. + +@cindex valeurs monadiques +@cindex fonctions monadiques +C'est là que le module @code{(guix monads)} arrive à la rescousse. Ce +module fournit un cadre pour travailler avec des @dfn{monads}, en +particulier une monad très utile pour notre usage, la @dfn{monad du dépôt}. +Les monads 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 monad — les valeurs qui contiennent ce +contexte supplémentaire — sont appelées des @dfn{valeurs monadiques} ; les +procédures qui renvoient ce genre de valeur sont appelées des +@dfn{procédures monadiques}. + +Considérez cette procédure « normale » : @example (define (sh-symlink store) - ;; Return a derivation that symlinks the 'bash' executable. + ;; 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"))) @@ -4874,27 +4916,28 @@ Consider this ``normal'' procedure: `(symlink ,sh %output)))) @end example -Using @code{(guix monads)} and @code{(guix gexp)}, it may be rewritten as a -monadic function: +En utilisant @code{(guix monads)} et @code{(guix gexp)}, on peut la réécrire +en une fonction monadique : @example (define (sh-symlink) - ;; Same, but return a monadic value. + ;; Pareil, mais renvoie une valeur monadique. (mlet %store-monad ((drv (package->derivation bash))) (gexp->derivation "sh" #~(symlink (string-append #$drv "/bin/bash") #$output)))) @end example -There are several things to note in the second version: the @code{store} -parameter is now implicit and is ``threaded'' in the calls to the -@code{package->derivation} and @code{gexp->derivation} monadic procedures, -and the monadic value returned by @code{package->derivation} is @dfn{bound} -using @code{mlet} instead of plain @code{let}. +Il y a plusieurs choses à remarquer avec cette deuxième version : le +paramètre @code{store} est maintenant implicitement « enfilé » dans les +appels aux procédures monadiques @code{package->derivation} et +@code{gexp->derivation}, et la valeur monadique renvoyée par +@code{package->derivation} est @dfn{liée} avec @code{mlet} plutôt qu'avec un +simple @code{let}. -As it turns out, the call to @code{package->derivation} can even be omitted -since it will take place implicitly, as we will see later -(@pxref{G-Expressions}): +Il se trouve que l'appel à @code{package->derivation} peut même être omis +puisqu'il aura lieu implicitement, comme nous le verrons plus tard +(@pxref{G-Expressions}) : @example (define (sh-symlink) @@ -4906,28 +4949,32 @@ since it will take place implicitly, as we will see later @c See @c <https://syntaxexclamation.wordpress.com/2014/06/26/escaping-continuations/> @c for the funny quote. -Calling the monadic @code{sh-symlink} has no effect. As someone once said, -``you exit a monad like you exit a building on fire: by running''. So, to -exit the monad and get the desired effect, one must use -@code{run-with-store}: +L'appel à la procédure monadique @code{sh-symlink} n'a aucun effet. En +anglais on pourrait dire « you exit a monad like you exit a building on +fire: by running »@footnote{NdT : « on sort d'une monad comme d'un immeuble +en flamme, en courant ». Le jeu de mot est perdu à la traduction : courrir +et lancer utilisent le même verbe @i{run} en anglais.}. Donc, pour sortir de +la monad et obtenir l'effet escompté, on doit utiliser +@code{run-with-store}. @example (run-with-store (open-connection) (sh-symlink)) @result{} /gnu/store/...-sh-symlink @end example -Note that the @code{(guix monad-repl)} module extends the Guile REPL with -new ``meta-commands'' to make it easier to deal with monadic procedures: -@code{run-in-store}, and @code{enter-store-monad}. The former is used to -``run'' a single monadic value through the store: +Remarquez que le module @code{(guix monad-repl)} étend la console Guile avec +de nouvelles « méta-commandes » pour rendre plus facile la manipulation de +procédures monadiques : @code{run-in-store} et @code{enter-store-monad}. La +première est utilisée pour « lancer » une seule valeur monadique à travers +le dépôt : @example scheme@@(guile-user)> ,run-in-store (package->derivation hello) $1 = #<derivation /gnu/store/@dots{}-hello-2.9.drv => @dots{}> @end example -The latter enters a recursive REPL, where all the return values are -automatically run through the store: +La deuxième entre dans une console récursive, où toutes les valeurs de +retour sont automatiquement lancées à travers le dépôt : @example scheme@@(guile-user)> ,enter-store-monad @@ -4940,27 +4987,28 @@ scheme@@(guile-user)> @end example @noindent -Note that non-monadic values cannot be returned in the @code{store-monad} -REPL. +Remarquez qu'on ne peut pas renvoyer de valeur non monadique dans la console +@code{store-monad}. -The main syntactic forms to deal with monads in general are provided by the -@code{(guix monads)} module and are described below. +Les formes syntaxiques principales pour utiliser des monads en général sont +disponibles dans le module @code{(guix monads)} et sont décrites ci-dessous. -@deffn {Scheme Syntax} with-monad @var{monad} @var{body} ... -Evaluate any @code{>>=} or @code{return} forms in @var{body} as being in -@var{monad}. +@deffn {Syntaxe Scheme} with-monad @var{monad} @var{body} ... +Évalue n'importe quelle forme @code{>>=} ou @code{return} dans @var{body} +comme une @var{monad}. @end deffn -@deffn {Scheme Syntax} return @var{val} -Return a monadic value that encapsulates @var{val}. +@deffn {Syntaxe Scheme} return @var{val} +Renvoie une valeur monadique qui encapsule @var{val}. @end deffn -@deffn {Scheme Syntax} >>= @var{mval} @var{mproc} ... -@dfn{Bind} monadic value @var{mval}, passing its ``contents'' to monadic -procedures @var{mproc}@dots{}@footnote{This operation is commonly referred -to as ``bind'', but that name denotes an unrelated procedure in Guile. Thus -we use this somewhat cryptic symbol inherited from the Haskell language.}. -There can be one @var{mproc} or several of them, as in this example: +@deffn {Syntaxe Scheme} >>= @var{mval} @var{mproc} ... +@dfn{Lie} une valeur monadique @var{mval}, en passant son « contenu » aux +procédures monadiques @var{mproc}@dots{}@footnote{Cette opération est +souvent appelée « bind », mais ce nom dénote une procédure qui n'a rien à +voir en Guile. Ainsi, nous empruntons ce symbole quelque peu cryptique au +langage Haskell}. Il peut y avoir une ou plusieurs @code{mproc}, comme dans +cet exemple : @example (run-with-state @@ -4975,60 +5023,63 @@ There can be one @var{mproc} or several of them, as in this example: @end example @end deffn -@deffn {Scheme Syntax} mlet @var{monad} ((@var{var} @var{mval}) ...) @ +@deffn {Syntaxe Scheme} mlet @var{monad} ((@var{var} @var{mval}) ...) @ + @var{body} ... +@deffnx {Syntaxe Scheme} mlet* @var{monad} ((@var{var} @var{mval}) ...) @ @var{body} ... -@deffnx {Scheme Syntax} mlet* @var{monad} ((@var{var} @var{mval}) ...) @ - @var{body} ... Bind the variables @var{var} to the monadic values -@var{mval} in @var{body}, which is a sequence of expressions. As with the -bind operator, this can be thought of as ``unpacking'' the raw, non-monadic -value ``contained'' in @var{mval} and making @var{var} refer to that raw, -non-monadic value within the scope of the @var{body}. The form (@var{var} --> @var{val}) binds @var{var} to the ``normal'' value @var{val}, as per -@code{let}. The binding operations occur in sequence from left to right. -The last expression of @var{body} must be a monadic expression, and its -result will become the result of the @code{mlet} or @code{mlet*} when run in -the @var{monad}. - -@code{mlet*} is to @code{mlet} what @code{let*} is to @code{let} +Lie les variables @var{var} aux valeurs monadiques @var{mval} dans +@var{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 @var{mval} et comme si on faisait en sorte que @var{var} se réfère à +cette valeur pure, non-monadique, dans la portée de @var{body}. La forme +(@var{var} -> @var{val}) lie @var{var} à la valeur « normale » @var{val}, +comme @code{let}. L'opération de liaison a lieu en séquence de la gauche +vers la droite. La dernière expression de @var{body} doit être une +expression monadique et son résultat deviendra le résultat de @code{mlet} ou +@code{mlet*} lorsque lancé dans la @var{monad}. + +@code{mlet*} est à @code{mlet} ce que @code{let*} est à @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}). @end deffn -@deffn {Scheme System} mbegin @var{monad} @var{mexp} ... -Bind @var{mexp} and the following monadic expressions in sequence, returning -the result of the last expression. Every expression in the sequence must be -a monadic expression. +@deffn {Système Scheme} mbegin @var{monad} @var{mexp} ... +Lie @var{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. -This is akin to @code{mlet}, except that the return values of the monadic -expressions are ignored. In that sense, it is analogous to @code{begin}, -but applied to monadic expressions. +Cette procédure est similaire à @code{mlet}, sauf que les valeurs de retour +des expressions monadiques sont ignorées. Dans ce sens, elle est analogue à +@code{begin}, mais appliqué à des expressions monadiques. @end deffn -@deffn {Scheme System} mwhen @var{condition} @var{mexp0} @var{mexp*} ... -When @var{condition} is true, evaluate the sequence of monadic expressions -@var{mexp0}..@var{mexp*} as in an @code{mbegin}. When @var{condition} is -false, return @code{*unspecified*} in the current monad. Every expression -in the sequence must be a monadic expression. +@deffn {Système Scheme} mwhen @var{condition} @var{mexp0} @var{mexp*} ... +Lorsque la @var{condition} est vraie, évalue la séquence des expressions +monadiques @var{mexp0}..@var{mexp*} comme dans un @code{mbegin}. Lorsque la +@var{condition} est fausse, renvoie @code{*unspecified*} dans la monad +actuelle. Cahque expression dans la séquence doit être une expression +monadique. @end deffn -@deffn {Scheme System} munless @var{condition} @var{mexp0} @var{mexp*} ... -When @var{condition} is false, evaluate the sequence of monadic expressions -@var{mexp0}..@var{mexp*} as in an @code{mbegin}. When @var{condition} is -true, return @code{*unspecified*} in the current monad. Every expression in -the sequence must be a monadic expression. +@deffn {Système Scheme} munless @var{condition} @var{mexp0} @var{mexp*} ... +Lorsque la @var{condition} est fausse, évalue la séquence des expressions +monadiques @var{mexp0}..@var{mexp*} comme dans un @code{mbegin}. Lorsque la +@var{condition} est vraie, renvoie @code{*unspecified*} dans la monad +actuelle. Cahque expression dans la séquence doit être une expression +monadique. @end deffn -@cindex state monad -The @code{(guix monads)} module provides the @dfn{state monad}, which allows -an additional value---the state---to be @emph{threaded} through monadic -procedure calls. +@cindex monad d'état +Le module @code{(guix monads)} fournit la @dfn{monad d'état} qui permet à +une valeur supplémentaire — l'état — d'être enfilée à travers les appels de +procédures. -@defvr {Scheme Variable} %state-monad -The state monad. Procedures in the state monad can access and change the -state that is threaded. +@defvr {Variable Scheme} %state-monad +La monad d'état. les procédure dans la monad d'état peuvent accéder et +modifier l'état qui est enfilé. -Consider the example below. The @code{square} procedure returns a value in -the state monad. It returns the square of its argument, but also increments -the current state value: +Considérez l'exemple ci-dessous. La procédure @code{square} renvoie une +valeur dans la monad d'état. Elle renvoie le carré de son argument, mais +incrémente aussi la valeur actuelle de l'état : @example (define (square x) @@ -5042,71 +5093,82 @@ the current state value: @result{} 3 @end example -When ``run'' through @var{%state-monad}, we obtain that additional state -value, which is the number of @code{square} calls. +Lorsqu'on la lance à travers @var{%state-monad}, on obtient cet valeur +d'état supplémentaire, qui est le nombre d'appels à @code{square}. @end defvr -@deffn {Monadic Procedure} current-state -Return the current state as a monadic value. +@deffn {Procédure Monadic} current-state +Renvoie l'état actuel dans une valeur monadique. @end deffn -@deffn {Monadic Procedure} set-current-state @var{value} -Set the current state to @var{value} and return the previous state as a -monadic value. +@deffn {Procédure Monadic} set-current-state @var{value} +Initialise l'état actuel à @var{value} et renvoie l'état précédent dans une +valeur monadique. @end deffn -@deffn {Monadic Procedure} state-push @var{value} -Push @var{value} to the current state, which is assumed to be a list, and -return the previous state as a monadic value. +@deffn {Procédure Monadic} state-push @var{value} +Pousse @var{value} sur l'état actuel, qui est supposé être une liste, et +renvoie l'état précédent dans une valeur monadique. @end deffn -@deffn {Monadic Procedure} state-pop -Pop a value from the current state and return it as a monadic value. The -state is assumed to be a list. +@deffn {Procédure Monadic} 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. @end deffn -@deffn {Scheme Procedure} run-with-state @var{mval} [@var{state}] -Run monadic value @var{mval} starting with @var{state} as the initial -state. Return two values: the resulting value, and the resulting state. +@deffn {Procédure Scheme} run-with-state @var{mval} [@var{state}] +Lance la valeur monadique @var{mval} avec @var{state} comme valeur +initiale. Renvoie deux valeurs : la valeur du résultat et l'état du +résultat. @end deffn -The main interface to the store monad, provided by the @code{(guix store)} -module, is as follows. +L'interface principale avec la monad du dépôt, fournit par le module +@code{(guix store)}, est la suivante. -@defvr {Scheme Variable} %store-monad -The store monad---an alias for @var{%state-monad}. +@defvr {Variable Scheme} %store-monad +La monad du dépôt — un alias pour @var{%state-monad}. -Values in the store monad encapsulate accesses to the store. When its -effect is needed, a value of the store monad must be ``evaluated'' by -passing it to the @code{run-with-store} procedure (see below.) +Les valeurs dans la monad du dépôt encapsulent des accès au dépôt. Lorsque +son effet est requis, une valeur de la monad du dépôt doit être « évaluée » +en la passant à la procédure @code{run-with-store} (voir plus bas). @end defvr -@deffn {Scheme Procedure} run-with-store @var{store} @var{mval} [#:guile-for-build] [#:system (%current-system)] -Run @var{mval}, a monadic value in the store monad, in @var{store}, an open -store connection. +@deffn {Procédure Scheme} run-with-store @var{store} @var{mval} [#:guile-for-build] [#:system (%current-system)] +Lance @var{mval}, une valeur monadique dans la monad du dépôt, dans +@var{store}, une connexion ouvert au dépôt. @end deffn -@deffn {Monadic Procedure} text-file @var{name} @var{text} [@var{references}] +@deffn {Procédure Monadique} text-file @var{name} @var{text} [@var{references}] +Renvoie une valeur monadique correspondant au nom de fichier dans le dépôt +du fichier contenant @var{text}, une chaîne de caractères. @var{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. +@end deffn + +@deffn {Monadic Procedure} binary-file @var{name} @var{data} [@var{references}] Return as a monadic value the absolute file name in the store of the file -containing @var{text}, a string. @var{references} is a list of store items -that the resulting text file refers to; it defaults to the empty list. +containing @var{data}, a bytevector. @var{references} is a list of store +items that the resulting binary file refers to; it defaults to the empty +list. @end deffn -@deffn {Monadic Procedure} interned-file @var{file} [@var{name}] @ - [#:recursive? #t] [#:select? (const #t)] Return the name of @var{file} once -interned in the store. Use @var{name} as its store name, or the basename of -@var{file} if @var{name} is omitted. +@deffn {Procédure Monadique} interned-file @var{file} [@var{name}] @ + [#:recursive? #t] [#:select? (const #t)] +Renvoie le nom de @var{file} une fois ajouté au dépôt. Utilise @var{name} +comme nom dans le dépôt ou le nom de fichier de @var{file} si @var{name} est +omis. -When @var{recursive?} is true, the contents of @var{file} are added -recursively; if @var{file} designates a flat file and @var{recursive?} is -true, its contents are added, and its permission bits are kept. +Lorsque @var{recursive?} est vraie, le contenu de @var{file} est ajouté +récursivement ; si @var{file} désigne un fichier simple et que +@var{recursive?} est vrai, son contenu est ajouté et ses bits de permissions +sont préservés. -When @var{recursive?} is true, call @code{(@var{select?} @var{file} -@var{stat})} for each directory entry, where @var{file} is the entry's -absolute file name and @var{stat} is the result of @code{lstat}; exclude -entries for which @var{select?} does not return true. +Lorsque @var{recursive?} est vraie, appelle @code{(@var{select?} @var{file} +@var{stat})} pour chaque répertoire où @var{file} est le nom de fichier +absolu de l'entrée et @var{stat} est le résultat de @code{lstat} ; à +l'exception des entrées pour lesquelles @var{select?} ne renvoie pas vrai. -The example below adds a file to the store, under two different names: +L'exemple ci-dessous ajoute un fichier au dépôt, sous deux noms différents : @example (run-with-store (open-connection) @@ -5119,20 +5181,23 @@ The example below adds a file to the store, under two different names: @end deffn -The @code{(guix packages)} module exports the following package-related -monadic procedures: - -@deffn {Monadic Procedure} package-file @var{package} [@var{file}] @ - [#:system (%current-system)] [#:target #f] @ [#:output "out"] Return as a -monadic value in the absolute file name of @var{file} within the -@var{output} directory of @var{package}. When @var{file} is omitted, return -the name of the @var{output} directory of @var{package}. When @var{target} -is true, use it as a cross-compilation target triplet. +Le module @code{(guix packages)} exporte les procédures monadiques liées aux +paquets suivantes : + +@deffn {Procédure Monadique} package-file @var{package} [@var{file}] @ + [#:system (%current-system)] [#:target #f] @ +[#:output "out"] +Renvoie une valeur monadique qui contient le nom de fichier absolu de +@var{file} dans le répertoire @var{output} de @var{package}. Lorsque +@var{file} est omis, renvoie le nom du répertoire @var{output} de +@var{package}. Lorsque @var{target} est vrai, l'utilise comme un triplet de +cible pour la compilation croisée. @end deffn -@deffn {Monadic Procedure} package->derivation @var{package} [@var{system}] -@deffnx {Monadic Procedure} package->cross-derivation @var{package} @ - @var{target} [@var{system}] Monadic version of @code{package-derivation} and +@deffn {Procédure Monadique} package->derivation @var{package} [@var{system}] +@deffnx {Procédure Monadique} package->cross-derivation @var{package} @ + @var{target} [@var{system}] +Version monadique de @code{package-derivation} et @code{package-cross-derivation} (@pxref{Définition des paquets}). @end deffn @@ -5141,64 +5206,69 @@ is true, use it as a cross-compilation target triplet. @section G-Expressions @cindex G-expression -@cindex build code quoting -So we have ``derivations'', which represent a sequence of build actions to -be performed to produce an item in the store (@pxref{Dérivations}). These -build actions are performed when asking the daemon to actually build the -derivations; they are run by the daemon in a container (@pxref{Invoquer guix-daemon}). - -@cindex strata of code -It should come as no surprise that we like to write these build actions in -Scheme. When we do that, we end up with two @dfn{strata} of Scheme -code@footnote{The term @dfn{stratum} in this context was coined by Manuel -Serrano et al.@: in the context of their work on Hop. Oleg Kiselyov, who -has written insightful -@url{http://okmij.org/ftp/meta-programming/#meta-scheme, essays and code on -this topic}, refers to this kind of code generation as @dfn{staging}.}: the -``host code''---code that defines packages, talks to the daemon, etc.---and -the ``build code''---code that actually performs build actions, such as -making directories, invoking @command{make}, etc. - -To describe a derivation and its build actions, one typically needs to embed -build code inside host code. It boils down to manipulating build code as -data, and the homoiconicity of Scheme---code has a direct representation as -data---comes in handy for that. But we need more than the normal -@code{quasiquote} mechanism in Scheme to construct build expressions. - -The @code{(guix gexp)} module implements @dfn{G-expressions}, a form of -S-expressions adapted to build expressions. G-expressions, or @dfn{gexps}, -consist essentially of three syntactic forms: @code{gexp}, @code{ungexp}, -and @code{ungexp-splicing} (or simply: @code{#~}, @code{#$}, and -@code{#$@@}), which are comparable to @code{quasiquote}, @code{unquote}, and -@code{unquote-splicing}, respectively (@pxref{Expression Syntax, -@code{quasiquote},, guile, GNU Guile Reference Manual}). However, there are -major differences: +@cindex quoting du code de construction +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 +(@pxref{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 (@pxref{Invoquer guix-daemon}). + +@cindex strate de code +Ça ne devrait pas vous surprendre, mais nous aimons écrire ces actions de +construction en Scheme. Lorsqu'on fait ça, on fini avec deux @dfn{strates} +de code Scheme@footnote{Le terme @dfn{strate} dans ce contexte a été inventé +par Manuel Serrano et ses collaborateurs dans le contexte de leur travaux +sur Hop. Oleg Kiselyov, qui a écrit des +@url{http://okmij.org/ftp/meta-programming/#meta-scheme, essais perspicaces +et du code sur le sujet}, utilise le terme de « mise en scène » pour ce +genre de génération de code.} : le « code hôte » — le code qui défini 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 @code{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 +@code{quasiquote} en Scheme pour construire des expressions de construction. + +Le module @code{(guix gexp)} implémente les @dfn{G-expressions}, une forme +de S-expression adaptée aux expressions de construction. Les G-expression, +ou @dfn{gexps}, consistent en gros en trois formes syntaxiques : +@code{gexp}, @code{ungexp} et @code{ungexp-splicing} (ou plus simplement : +@code{#~}, @code{#$} et @code{#$@@}), qui sont comparable à +@code{quasiquote}, @code{unquote} ett @code{unquote-splicing} respectivement +(@pxref{Expression Syntax, @code{quasiquote},, guile, GNU Guile Reference +Manual}). Cependant il y a des différences majeures : @itemize @item -Gexps are meant to be written to a file and run or manipulated by other -processes. +Les Gexps sont conçues pour être écrites dans un fichier et être lancées ou +manipulées par d'autres processus. @item -When a high-level object such as a package or derivation is unquoted inside -a gexp, the result is as if its output file name had been introduced. +Lorsqu'un objet de haut-niveau comme un paquet ou une dérivation est +unquotée dans une gexp, le résultat est comme si le nom de fichier de son +résultat avait été introduit. @item -Gexps carry information about the packages or derivations they refer to, and -these dependencies are automatically added as inputs to the build processes -that use them. +Les gexps transportent des informatinos sur les paquets ou les dérivations +auxquels elles se réfèrent, et ces dépendances sont automatiquement ajoutées +comme des entrées du processus de construction qui les utilise. @end itemize -@cindex lowering, of high-level objects in gexps -This mechanism is not limited to package and derivation objects: -@dfn{compilers} able to ``lower'' other high-level objects to derivations or -files in the store can be defined, such that these objects can also be -inserted into gexps. For example, a useful type of high-level objects that -can be inserted in a gexp is ``file-like objects'', which make it easy to -add files to the store and to refer to them in derivations and such (see -@code{local-file} and @code{plain-file} below.) +@cindex abaissement, des objets haut-niveau dans les gepxs +Ce mécanisme n'est pas limité aux paquets et aux dérivations : on peut +définir des @dfn{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 +@code{local-file} et @code{plain-file} ci-dessous). -To illustrate the idea, here is an example of a gexp: +Pour illustrer cette idée, voici un exemple de gexp : @example (define build-exp @@ -5209,27 +5279,28 @@ To illustrate the idea, here is an example of a gexp: "list-files"))) @end example -This gexp can be passed to @code{gexp->derivation}; we obtain a derivation -that builds a directory containing exactly one symlink to -@file{/gnu/store/@dots{}-coreutils-8.22/bin/ls}: +Cette gexp peut être passée à @code{gexp->derivation} ; on obtient une +dérivation qui construit une répertoire contenant exactement un lien +symbolique à @file{/gnu/store/@dots{}-coreutils-8.22/bin/ls} : @example (gexp->derivation "the-thing" build-exp) @end example -As one would expect, the @code{"/gnu/store/@dots{}-coreutils-8.22"} string -is substituted to the reference to the @var{coreutils} package in the actual -build code, and @var{coreutils} is automatically made an input to the -derivation. Likewise, @code{#$output} (equivalent to @code{(ungexp -output)}) is replaced by a string containing the directory name of the -output of the derivation. +Comme on pourrait s'y attendre, la chaîne +@code{"/gnu/store/@dots{}-coreutils-8.22"} est substituée à la place de la +référence au paquet @var{coreutils} dans le code de construction final, et +@var{coreutils} est automatiquement devenu une entrée de la dérivation. De +même, @code{#$output} (équivalent à @code{(ungexp output)}) est remplacé par +une chaîne de caractères contenant le nom du répertoire de la sortie de la +dérivation. -@cindex cross compilation -In a cross-compilation context, it is useful to distinguish between -references to the @emph{native} build of a package---that can run on the -host---versus references to cross builds of a package. To that end, the -@code{#+} plays the same role as @code{#$}, but is a reference to a native -package build: +@cindex compilation croisée +Dans le contexte d'une compilation croisée, il est utile de distinguer entre +des références à la construction @emph{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, @code{#+} joue le même rôle que @code{#$}, mais référence une +construction native d'un paquet : @example (gexp->derivation "vi" @@ -5243,16 +5314,17 @@ package build: @end example @noindent -In the example above, the native build of @var{coreutils} is used, so that -@command{ln} can actually run on the host; but then the cross-compiled build -of @var{emacs} is referenced. +Dans l'exemple ci-dessus, la construction native de @var{coreutils} est +utilisée, pour que @command{ln} puisse effectivement être lancé sur l'hôte ; +mais ensuite la construction croisée d'@var{emacs} est utilisée. -@cindex imported modules, for gexps +@cindex modules importés, pour les gexps @findex with-imported-modules -Another gexp feature is @dfn{imported modules}: sometimes you want to be -able to use certain Guile modules from the ``host environment'' in the gexp, -so those modules should be imported in the ``build environment''. The -@code{with-imported-modules} form allows you to express that: +Une autre fonctionnalité, ce sont les @dfn{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 @code{with-imported-modules} +vous permet d'exprimer ça : @example (let ((build (with-imported-modules '((guix build utils)) @@ -5267,21 +5339,21 @@ so those modules should be imported in the ``build environment''. The @end example @noindent -In this example, the @code{(guix build utils)} module is automatically -pulled into the isolated build environment of our gexp, such that -@code{(use-modules (guix build utils))} works as expected. +Dans cet exemple, le module @code{(guix build utils)} est automatiquement +récupéré dans l'environnement de construction isolé de notre gexp, pour que +@code{(use-modules (guix build utils))} fonctionne comme on s'y attendrait. -@cindex module closure +@cindex closure de module @findex source-module-closure -Usually you want the @emph{closure} of the module to be imported---i.e., the -module itself and all the modules it depends on---rather than just the -module; failing to do that, attempts to use the module will fail because of -missing dependent modules. The @code{source-module-closure} procedure -computes the closure of a module by looking at its source file headers, -which comes in handy in this case: +Typiquement, vous voudriez que la @emph{closure} complète du mondule 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 +@code{source-module-closure} calcule la closure d'un module en cherchant +dans ses en-têtes sources, ce qui est pratique dans ce cas : @example -(use-modules (guix modules)) ;for 'source-module-closure' +(use-modules (guix modules)) ;pour 'source-module-closure' (with-imported-modules (source-module-closure '((guix build utils) @@ -5293,15 +5365,16 @@ which comes in handy in this case: @dots{}))) @end example -@cindex extensions, for gexps +@cindex extensions, des gexps @findex with-extensions -In the same vein, sometimes you want to import not just pure-Scheme modules, -but also ``extensions'' such as Guile bindings to C libraries or other -``full-blown'' packages. Say you need the @code{guile-json} package -available on the build side, here's how you would do it: +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 @code{guile-json} du côté de la construction, +voici comme procéder : @example -(use-modules (gnu packages guile)) ;for 'guile-json' +(use-modules (gnu packages guile)) ;pour 'guile-json' (with-extensions (list guile-json) (gexp->derivation "something-with-json" @@ -5310,72 +5383,73 @@ available on the build side, here's how you would do it: @dots{}))) @end example -The syntactic form to construct gexps is summarized below. +La forme syntaxique pour construire des gexps est résumée ci-dessous. -@deffn {Scheme Syntax} #~@var{exp} -@deffnx {Scheme Syntax} (gexp @var{exp}) -Return a G-expression containing @var{exp}. @var{exp} may contain one or -more of the following forms: +@deffn {Syntaxe Scheme} #~@var{exp} +@deffnx {Syntaxe Scheme} (gexp @var{exp}) +Renvoie une G-expression contenant @var{exp}. @var{exp} peut contenir une +ou plusieurs de ces formes : @table @code @item #$@var{obj} @itemx (ungexp @var{obj}) -Introduce a reference to @var{obj}. @var{obj} may have one of the supported -types, for example a package or a derivation, in which case the -@code{ungexp} form is replaced by its output file name---e.g., +Introduit une référence à @var{obj}. @var{obj} peut être d'un des types +supportés, par exemple un paquet ou une dérivation, auquel cas la forme +@code{ungexp} est remplacée par le nom de fichier de sa sortie — p.@: ex.@: @code{"/gnu/store/@dots{}-coreutils-8.22}. -If @var{obj} is a list, it is traversed and references to supported objects -are substituted similarly. +Si @var{boj} est une liste, elle est traversée et les références aux objets +supportés sont substitués de manière similaire. -If @var{obj} is another gexp, its contents are inserted and its dependencies -are added to those of the containing gexp. +Si @var{obj} est une autre gexp, son contenu est inséré et ses dépendances +sont ajoutées à celle de la gexp qui l'entoure. -If @var{obj} is another kind of object, it is inserted as is. +Si @var{obj} est un autre type d'objet, il est inséré tel quel. @item #$@var{obj}:@var{output} @itemx (ungexp @var{obj} @var{output}) -This is like the form above, but referring explicitly to the @var{output} of -@var{obj}---this is useful when @var{obj} produces multiple outputs -(@pxref{Des paquets avec plusieurs résultats}). +Cette forme est similaire à la précédente, mais se réfère explicitement à la +sortie @var{output} de l'objet @var{obj} — c'est utile lorsque @var{obj} +produit plusieurs sorties (@pxref{Des paquets avec plusieurs résultats}). @item #+@var{obj} @itemx #+@var{obj}:output @itemx (ungexp-native @var{obj}) @itemx (ungexp-native @var{obj} @var{output}) -Same as @code{ungexp}, but produces a reference to the @emph{native} build -of @var{obj} when used in a cross compilation context. +Comme @code{ungexp}, mais produit une référence à la construction +@emph{native} de @var{obj} lorsqu'elle est utilisée dans une compilation +croisée. @item #$output[:@var{output}] @itemx (ungexp output [@var{output}]) -Insert a reference to derivation output @var{output}, or to the main output -when @var{output} is omitted. +Insère une référence à la sortie @var{output} de la dérivation, ou à la +sortie principale lorsque @var{output} est omis. -This only makes sense for gexps passed to @code{gexp->derivation}. +Cela ne fait du sens que pour les gexps passées à @code{gexp->derivation}. @item #$@@@var{lst} @itemx (ungexp-splicing @var{lst}) -Like the above, but splices the contents of @var{lst} inside the containing -list. +Comme au dessus, mais recolle (@i{splice}) le contenu de @var{lst} dans la +liste qui la contient. @item #+@@@var{lst} @itemx (ungexp-native-splicing @var{lst}) -Like the above, but refers to native builds of the objects listed in -@var{lst}. +Comme au dessus, mais se réfère à la construction native des objets listés +dans @var{lst}. @end table -G-expressions created by @code{gexp} or @code{#~} are run-time objects of -the @code{gexp?} type (see below.) +Les G-expressions crées par @code{gexp} ou @code{#~} sont des objets à +l'exécution du type @code{gexp?} (voir plus bas). @end deffn -@deffn {Scheme Syntax} with-imported-modules @var{modules} @var{body}@dots{} -Mark the gexps defined in @var{body}@dots{} as requiring @var{modules} in -their execution environment. +@deffn {Syntaxe Scheme} with-imported-modules @var{modules} @var{body}@dots{} +Marque les gexps définies dans @var{body}@dots{} comme requérant +@var{modules} dans leur environnement d'exécution. -Each item in @var{modules} can be the name of a module, such as @code{(guix -build utils)}, or it can be a module name, followed by an arrow, followed by -a file-like object: +Chaque élément dans @var{module} peut être le nom d'un module, comme +@code{(guix build utils)} ou le nom d'un module suivi d'une flêche, suivie +d'un objet simili-fichier : @example `((guix build utils) @@ -5385,63 +5459,71 @@ a file-like object: @end example @noindent -In the example above, the first two modules are taken from the search path, -and the last one is created from the given file-like object. +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. -This form has @emph{lexical} scope: it has an effect on the gexps directly -defined in @var{body}@dots{}, but not on those defined, say, in procedures -called from @var{body}@dots{}. +Cette forme a une portée @emph{lexicale} : elle a un effet sur les gexp +directement définies dans @var{body}@dots{}, mais pas sur celles définies +dans des procédures appelées par @var{body}@dots{}. @end deffn -@deffn {Scheme Syntax} with-extensions @var{extensions} @var{body}@dots{} -Mark the gexps defined in @var{body}@dots{} as requiring @var{extensions} in -their build and execution environment. @var{extensions} is typically a list -of package objects such as those defined in the @code{(gnu packages guile)} -module. +@deffn {Syntaxe Scheme} with-extensions @var{extensions} @var{body}@dots{} +Marque les gexps définies dans @var{body}@dots{} comme requérant +@var{extensions} dans leur environnement de construction et d'exécution. +@var{extensions} est typiquement une liste d'objets paquets comme définis +dans le module @code{(gnu packages guile)}. -Concretely, the packages listed in @var{extensions} are added to the load -path while compiling imported modules in @var{body}@dots{}; they are also -added to the load path of the gexp returned by @var{body}@dots{}. +Concrètement, les paquets listés dans @var{extensions} sont ajoutés au +chemin de chargement lors de la compilation des modules importés dans +@var{body}@dots{} ; ils sont aussi ajoutés au chemin de chargement de la +gexp renvoyée par @var{body}@dots{}. @end deffn -@deffn {Scheme Procedure} gexp? @var{obj} -Return @code{#t} if @var{obj} is a G-expression. +@deffn {Procédure Scheme} gexp? @var{obj} +Renvoie @code{#t} si @var{obj} est une G-expression. @end deffn -G-expressions are meant to be written to disk, either as code building some -derivation, or as plain files in the store. The monadic procedures below -allow you to do that (@pxref{La monad du dépôt}, for more information about -monads.) - -@deffn {Monadic Procedure} gexp->derivation @var{name} @var{exp} @ - [#:system (%current-system)] [#:target #f] [#:graft? #t] @ [#:hash #f] -[#:hash-algo #f] @ [#:recursive? #f] [#:env-vars '()] [#:modules '()] @ -[#:module-path @var{%load-path}] @ [#:effective-version "2.2"] @ +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 (@pxref{La monad du dépôt}, pour plus d'information sur les monads). + +@deffn {Procédure Monadique} gexp->derivation @var{name} @var{exp} @ + [#:system (%current-system)] [#:target #f] [#:graft? #t] @ +[#:hash #f] [#:hash-algo #f] @ +[#:recursive? #f] [#:env-vars '()] [#:modules '()] @ +[#:module-path @var{%load-path}] @ +[#:effective-version "2.2"] @ [#:references-graphs #f] [#:allowed-references #f] @ -[#:disallowed-references #f] @ [#:leaked-env-vars #f] @ [#:script-name -(string-append @var{name} "-builder")] @ [#:deprecation-warnings #f] @ -[#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f] Return a -derivation @var{name} that runs @var{exp} (a gexp) with -@var{guile-for-build} (a derivation) on @var{system}; @var{exp} is stored in -a file called @var{script-name}. When @var{target} is true, it is used as -the cross-compilation target triplet for packages referred to by @var{exp}. - -@var{modules} is deprecated in favor of @code{with-imported-modules}. Its -meaning is to make @var{modules} available in the evaluation context of -@var{exp}; @var{modules} is a list of names of Guile modules searched in -@var{module-path} to be copied in the store, compiled, and made available in -the load path during the execution of @var{exp}---e.g., @code{((guix build -utils) (guix build gnu-build-system))}. +[#:disallowed-references #f] @ +[#:leaked-env-vars #f] @ +[#:script-name (string-append @var{name} "-builder")] @ +[#:deprecation-warnings #f] @ +[#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f] +Renvoie une dérivation @var{name} qui lance @var{exp} (une gexp) avec +@var{guile-for-build} (une dérivation) sur @var{system} ; @var{exp} est +stocké dans un fichier appelé @var{script-name}. Lorsque @var{target} est +vraie, elle est utilisée comme triplet de cible de compilation croisée pour +les paquets référencés par @var{exp}. + +@var{modules} est devenu obsolète en faveur de +@code{with-imported-modules}. Sa signification est de rendre @var{modules} +disponibles dans le contexte d'évaluation de @var{exp} ; @var{modules} est +une liste de noms de modules Guile qui sont cherchés dans @var{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 @var{exp} — p.@: ex.@: +@code{((guix build utils) (guix build gnu-build-system))}. + +@var{effective-version} détermine la chaîne à utiliser lors d'ajout +d'extensions de @var{exp} (voir @code{with-extensions}) au chemin de +recherche — p.@: ex.@: @code{"2.2"}. + +@var{graft?} détermine si les paquets référencés par @var{exp} devraient +être greffés si possible. -@var{effective-version} determines the string to use when adding extensions -of @var{exp} (see @code{with-extensions}) to the search path---e.g., -@code{"2.2"}. - -@var{graft?} determines whether packages referred to by @var{exp} should be -grafted when applicable. - -When @var{references-graphs} is true, it must be a list of tuples of one of -the following forms: +Lorsque @var{references-graphs} est vrai, il doit s'agir d'une liste de +tuples de la forme suivante : @example (@var{file-name} @var{package}) @@ -5451,85 +5533,92 @@ the following forms: (@var{file-name} @var{store-item}) @end example -The right-hand-side of each element of @var{references-graphs} is -automatically made an input of the build process of @var{exp}. In the build -environment, each @var{file-name} contains the reference graph of the -corresponding item, in a simple text format. +La partie droite des éléments de @var{references-graphs} est automatiquement +transformée en une entrée du processus de construction @var{exp}. Dans +l'environnement de construction, chaque @var{file-name} contient le graphe +des références de l'élément correspondant, dans un format texte simple. -@var{allowed-references} must be either @code{#f} or a list of output names -and packages. In the latter case, the list denotes store items that the -result is allowed to refer to. Any reference to another store item will -lead to a build error. Similarly for @var{disallowed-references}, which can -list items that must not be referenced by the outputs. +@var{allowed-references} doit soit être @code{#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 @var{disallowed-references}, qui peut lister des éléments qui ne +doivent pas être référencés par les sorties. -@var{deprecation-warnings} determines whether to show deprecation warnings -while compiling modules. It can be @code{#f}, @code{#t}, or -@code{'detailed}. +@var{deprecation-warnings} détermine s'il faut afficher les avertissement +d'obsolescence à la compilation de modules. Il peut valoir @code{#f}, +@code{t} ou @code{'detailed}. -The other arguments are as for @code{derivation} (@pxref{Dérivations}). +Les autres arguments sont les mêmes que pour @code{derivation} +(@pxref{Dérivations}). @end deffn -@cindex file-like objects -The @code{local-file}, @code{plain-file}, @code{computed-file}, -@code{program-file}, and @code{scheme-file} procedures below return -@dfn{file-like objects}. That is, when unquoted in a G-expression, these -objects lead to a file in the store. Consider this G-expression: +@cindex objets simili-fichiers +Les procédures @code{local-file}, @code{plain-file}, @code{computed-file}, +@code{program-file} et @code{scheme-file} ci-dessous renvoient des +@dfn{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 : @example #~(system* #$(file-append glibc "/sbin/nscd") "-f" #$(local-file "/tmp/my-nscd.conf")) @end example -The effect here is to ``intern'' @file{/tmp/my-nscd.conf} by copying it to -the store. Once expanded, for instance @i{via} @code{gexp->derivation}, the -G-expression refers to that copy under @file{/gnu/store}; thus, modifying or -removing the file in @file{/tmp} does not have any effect on what the -G-expression does. @code{plain-file} can be used similarly; it differs in -that the file content is directly passed as a string. - -@deffn {Scheme Procedure} local-file @var{file} [@var{name}] @ - [#:recursive? #f] [#:select? (const #t)] Return an object representing local -file @var{file} to add to the store; this object can be used in a gexp. If -@var{file} is a relative file name, it is looked up relative to the source -file where this form appears. @var{file} will be added to the store under -@var{name}--by default the base name of @var{file}. - -When @var{recursive?} is true, the contents of @var{file} are added -recursively; if @var{file} designates a flat file and @var{recursive?} is -true, its contents are added, and its permission bits are kept. - -When @var{recursive?} is true, call @code{(@var{select?} @var{file} -@var{stat})} for each directory entry, where @var{file} is the entry's -absolute file name and @var{stat} is the result of @code{lstat}; exclude -entries for which @var{select?} does not return true. - -This is the declarative counterpart of the @code{interned-file} monadic -procedure (@pxref{La monad du dépôt, @code{interned-file}}). +Ici, l'effet est « d'internaliser » @file{/tmp/my-nscd.conf} en le copiant +dans le dépôt. Une fois étendu, par exemple via @code{gexp->derivation}, la +G-expression se réfère à cette copie dans @file{/gnu/store} ; ainsi, +modifier ou supprimer le fichier dans @file{/tmp} n'a aucun effet sur ce que +fait la G-expression. @code{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. + +@deffn {Procédure Scheme} local-file @var{file} [@var{name}] @ + [#:recursive? #f] [#:select? (const #t)] +Renvoie un objet représentant un fichier local @var{file} à ajouter au dépôt +; cet objet peut être utilisé dans une gexp. Si @var{file} est un nom de +fichier relatif, il est récupéré à partir de la position du fichier source +dans lequel il apparaît. @var{file} sera ajouté au dépôt sous le nom +@var{name} — par défaut le nom de base de @var{file}. + +Lorsque @var{recursive?} est vraie, le contenu de @var{file} est ajouté +récursivement ; si @var{file} désigne un fichier simple et que +@var{recursive?} est vrai, son contenu est ajouté et ses bits de permissions +sont préservés. + +Lorsque @var{recursive?} est vraie, appelle @code{(@var{select?} @var{file} +@var{stat})} pour chaque répertoire où @var{file} est le nom de fichier +absolu de l'entrée et @var{stat} est le résultat de @code{lstat} ; à +l'exception des entrées pour lesquelles @var{select?} ne renvoie pas vrai. + +C'est la version déclarative de la procédure monadique @code{interned-file} +(@pxref{La monad du dépôt, @code{interned-file}}). @end deffn -@deffn {Scheme Procedure} plain-file @var{name} @var{content} +@deffn {Procédure Scheme} plain-file @var{name} @var{content} Return an object representing a text file called @var{name} with the given -@var{content} (a string) to be added to the store. +@var{content} (a string or a bytevector) to be added to the store. -This is the declarative counterpart of @code{text-file}. +C'est la version déclarative de @code{text-file}. @end deffn -@deffn {Scheme Procedure} computed-file @var{name} @var{gexp} @ - [#:options '(#:local-build? #t)] Return an object representing the store -item @var{name}, a file or directory computed by @var{gexp}. @var{options} -is a list of additional arguments to pass to @code{gexp->derivation}. +@deffn {Procédure Scheme} computed-file @var{name} @var{gexp} @ + [#:options '(#:local-build? #t)] +Renvoie un objet représentant un élément du dépôt @var{name}, un fichier ou +un répertoire calculé par @var{gexp}. @var{options} est une liste +d'arguments supplémentaires à passer à @code{gexp->derivation}. -This is the declarative counterpart of @code{gexp->derivation}. +C'est la version déclarative de @code{gexp->derivation}. @end deffn -@deffn {Monadic Procedure} gexp->script @var{name} @var{exp} @ - [#:guile (default-guile)] [#:module-path %load-path] Return an executable -script @var{name} that runs @var{exp} using @var{guile}, with @var{exp}'s -imported modules in its search path. Look up @var{exp}'s modules in -@var{module-path}. +@deffn {Procédure monadique} gexp->script @var{name} @var{exp} @ + [#:guile (default-guile)] [#:module-path %load-path] +Renvoie un script exécutable @var{name} qui lance @var{exp} avec +@var{guile}, avec les modules importés de @var{exp} dans son chemin de +recherche. Cherche les modules de @var{exp} dans @var{module-path}. -The example below builds a script that simply invokes the @command{ls} -command: +L'exemple ci-dessous construit un script qui invoque simplement la commande +@command{ls} : @example (use-modules (guix gexp) (gnu packages base)) @@ -5539,9 +5628,9 @@ command: "ls")) @end example -When ``running'' it through the store (@pxref{La monad du dépôt, -@code{run-with-store}}), we obtain a derivation that produces an executable -file @file{/gnu/store/@dots{}-list-files} along these lines: +Lorsqu'elle est « lancée » à travers le dépôt (@pxref{La monad du dépôt, +@code{run-with-store}}), on obtient une dérivation qui produit une fichier +exécutable @file{/gnu/store/@dots{}-list-files} qui ressemble à : @example #!/gnu/store/@dots{}-guile-2.0.11/bin/guile -ds @@ -5550,107 +5639,115 @@ file @file{/gnu/store/@dots{}-list-files} along these lines: @end example @end deffn -@deffn {Scheme Procedure} program-file @var{name} @var{exp} @ - [#:guile #f] [#:module-path %load-path] Return an object representing the -executable store item @var{name} that runs @var{gexp}. @var{guile} is the -Guile package used to execute that script. Imported modules of @var{gexp} -are looked up in @var{module-path}. +@deffn {Procédure Scheme} program-file @var{name} @var{exp} @ + [#:guile #f] [#:module-path %load-path] +Renvoie un objet représentant un élément du dépôt @var{name} qui lance +@var{gexp}. @var{guile} est le paquet Guile à utiliser pour exécuter le +script. Les modules importés par @var{gexp} sont recherchés dans +@var{module-path}. -This is the declarative counterpart of @code{gexp->script}. +C'est la version déclarative de @code{gexp->script}. @end deffn -@deffn {Monadic Procedure} gexp->file @var{name} @var{exp} @ - [#:set-load-path? #t] [#:module-path %load-path] @ [#:splice? #f] @ [#:guile -(default-guile)] Return a derivation that builds a file @var{name} -containing @var{exp}. When @var{splice?} is true, @var{exp} is considered -to be a list of expressions that will be spliced in the resulting file. - -When @var{set-load-path?} is true, emit code in the resulting file to set -@code{%load-path} and @code{%load-compiled-path} to honor @var{exp}'s -imported modules. Look up @var{exp}'s modules in @var{module-path}. - -The resulting file holds references to all the dependencies of @var{exp} or -a subset thereof. +@deffn {Procédure monadique} gexp->file @var{name} @var{exp} @ + [#:set-load-path? #t] [#:module-path %load-path] @ +[#:splice? #f] @ +[#:guile (default-guile)] +Renvoie une dérivation qui construit un fichier @var{name} contenant +@var{exp}. Lorsque @var{splice?} est vrai, @var{exp} est considéré comme +une liste d'expressions qui seront splicée dans le fichier qui en résulte. + +Lorsque @var{set-load-path?} est vrai, émet du code dans le fichier de +résultat pour initialiser @code{%load-path} et @code{%load-compiled-path} +pour honorer les modules importés de @var{exp}. Les modules de @var{exp} +sont trouvés dans @var{module-path}. + +Le fichier qui en résulte retient les références à toutes les dépendances de +@var{exp} ou un sous-ensemble. @end deffn -@deffn {Scheme Procedure} derivation @var{store} @var{name} @var{builder} @ -Return an object representing the Scheme file @var{name} that contains +@deffn {Procédure Scheme} scheme-file @var{name} @var{exp} [#:splice? #f] +Renvoie un objet représentant le fichier Scheme @var{name} qui contient @var{exp}. -This is the declarative counterpart of @code{gexp->file}. +C'est la version déclarative de @code{gexp->file}. @end deffn -@deffn {Monadic Procedure} text-file* @var{name} @var{text} @dots{} -Return as a monadic value a derivation that builds a text file containing -all of @var{text}. @var{text} may list, in addition to strings, objects of -any type that can be used in a gexp: packages, derivations, local file -objects, etc. The resulting store file holds references to all these. +@deffn {Procédure monadique} text-file* @var{name} @var{text} @dots{} +Renvoie une valeur monadique qui construit un ficher texte contenant +@var{text}. @var{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. -This variant should be preferred over @code{text-file} anytime the file to -create will reference items from the store. This is typically the case when -building a configuration file that embeds store file names, like this: +Cette variante devrait être préférée à @code{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 : @example (define (profile.sh) - ;; Return the name of a shell script in the store that - ;; initializes the 'PATH' environment variable. + ;; 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")) @end example -In this example, the resulting @file{/gnu/store/@dots{}-profile.sh} file -will reference @var{coreutils}, @var{grep}, and @var{sed}, thereby -preventing them from being garbage-collected during its lifetime. +Dans cet exemple, le fichier @file{/gnu/store/@dots{}-profile.sh} qui en +résulte référence @var{coreutils}, @var{grep} et @var{sed}, ce qui les +empêche d'être glanés tant que le script est accessible. @end deffn -@deffn {Scheme Procedure} mixed-text-file @var{name} @var{text} @dots{} -Return an object representing store file @var{name} containing @var{text}. -@var{text} is a sequence of strings and file-like objects, as in: +@deffn {Procédure Scheme} mixed-text-file @var{name} @var{text} @dots{} +Renvoie un objet représentant le fichier du dépôt @var{name} contenant +@var{text}. @var{text} est une séquence de chaînes de caractères et de +fichiers simili-objets, comme dans : @example (mixed-text-file "profile" "export PATH=" coreutils "/bin:" grep "/bin") @end example -This is the declarative counterpart of @code{text-file*}. +C'est la version déclarative de @code{text-file*}. @end deffn -@deffn {Scheme Procedure} file-union @var{name} @var{files} -Return a @code{<computed-file>} that builds a directory containing all of -@var{files}. Each item in @var{files} must be a two-element list where the -first element is the file name to use in the new directory, and the second -element is a gexp denoting the target file. Here's an example: +@deffn {Procédure Scheme} file-union @var{name} @var{files} +Renvoie un @code{<computed-file>} qui construit un répertoire qui contient +tous les fichiers de @var{files}. Chaque élément de @var{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 : @example (file-union "etc" `(("hosts" ,(plain-file "hosts" "127.0.0.1 localhost")) ("bashrc" ,(plain-file "bashrc" - "alias ls='ls --color'")))) + "alias ls='ls --color=auto'")))) @end example -This yields an @code{etc} directory containing these two files. +Cela crée un répertoire @code{etc} contenant ces deux fichiers. @end deffn -@deffn {Scheme Procedure} directory-union @var{name} @var{things} -Return a directory that is the union of @var{things}, where @var{things} is -a list of file-like objects denoting directories. For example: +@deffn {Procédure Scheme} directory-union @var{name} @var{things} +Renvoie un répertoire qui est l'union de @var{things}, où @var{things} est +une liste d'objets simili-fichiers qui dénotent des répertoires. Par exemple +: @example (directory-union "guile+emacs" (list guile emacs)) @end example -yields a directory that is the union of the @code{guile} and @code{emacs} -packages. +crée un répertoire qui est l'union des paquets @code{guile} et @code{emacs}. @end deffn -@deffn {Scheme Procedure} file-append @var{obj} @var{suffix} @dots{} -Return a file-like object that expands to the concatenation of @var{obj} and -@var{suffix}, where @var{obj} is a lowerable object and each @var{suffix} is -a string. +@deffn {Procédure Scheme} file-append @var{obj} @var{suffix} @dots{} +Renvoie un objet simili-fichier qui correspond à la concaténation de +@var{obj} et @var{suffix} où @var{obj} est un objet abaissable et chaque +@var{suffix} est une chaîne de caractères. -As an example, consider this gexp: +Par exemple, considérez cette gexp : @example (gexp->script "run-uname" @@ -5658,7 +5755,7 @@ As an example, consider this gexp: "/bin/uname"))) @end example -The same effect could be achieved with: +On peut obtenir le même effet avec : @example (gexp->script "run-uname" @@ -5666,31 +5763,87 @@ The same effect could be achieved with: "/bin/uname"))) @end example -There is one difference though: in the @code{file-append} case, the -resulting script contains the absolute file name as a string, whereas in the -second case, the resulting script contains a @code{(string-append @dots{})} -expression to construct the file name @emph{at run time}. +Il y a une différence cependant : dans le cas @code{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 +@code{(string-append @dots{})} pour construire le nom de fichier @emph{à +l'exécution}. @end deffn -Of course, in addition to gexps embedded in ``host'' code, there are also -modules containing build tools. To make it clear that they are meant to be -used in the build stratum, these modules are kept in the @code{(guix build -@dots{})} name space. +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 @code{(guix build @dots{})}. + +@cindex abaissement, des objets haut-niveau dans les gepxs +En interne, les objets de haut-niveau sont @dfn{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 +@code{plain-file} crée un élément du dépôt. Cela est effectué par la +procédure monadique @code{lower-object}. + +@deffn {Procédure Monadique} lower-object @var{obj} [@var{system}] @ + [#:target #f] +Renvoie la dérivation ou l'élément du dépôt comme une valeur de +@var{%store-monad} qui correspond à @var{obj} pour @var{system}, en +compilant de manière croisée pour @var{target} si @var{target} est vrai. +@var{obj} doit être un objet qui a un compilateur de gexp associé, comme un +@code{<package>}. +@end deffn + +@node Invoking guix repl +@section Invoking @command{guix repl} -@cindex lowering, of high-level objects in gexps -Internally, high-level objects are @dfn{lowered}, using their compiler, to -either derivations or store items. For instance, lowering a package yields -a derivation, and lowering a @code{plain-file} yields a store item. This is -achieved using the @code{lower-object} monadic procedure. +@cindex REPL, read-eval-print loop +The @command{guix repl} command spawns a Guile @dfn{read-eval-print loop} +(REPL) for interactive programming (@pxref{Using Guile Interactively,,, +guile, GNU Guile Reference Manual}). Compared to just launching the +@command{guile} command, @command{guix repl} guarantees that all the Guix +modules and all its dependencies are available in the search path. You can +use it this way: -@deffn {Monadic Procedure} lower-object @var{obj} [@var{system}] @ - [#:target #f] Return as a value in @var{%store-monad} the derivation or -store item corresponding to @var{obj} for @var{system}, cross-compiling for -@var{target} if @var{target} is true. @var{obj} must be an object that has -an associated gexp compiler, such as a @code{<package>}. -@end deffn +@example +$ guix repl +scheme@@(guile-user)> ,use (gnu packages base) +scheme@@(guile-user)> coreutils +$1 = #<package coreutils@@8.29 gnu/packages/base.scm:327 3e28300> +@end example + +@cindex inferiors +In addition, @command{guix repl} implements a simple machine-readable REPL +protocol for use by @code{(guix inferior)}, a facility to interact with +@dfn{inferiors}, separate processes running a potentially different revision +of Guix. + +The available options are as follows: + +@table @code +@item --type=@var{type} +@itemx -t @var{type} +Start a REPL of the given @var{TYPE}, which can be one of the following: + +@table @code +@item guile +This is default, and it spawns a standard full-featured Guile REPL. +@item machine +Spawn a REPL that uses the machine-readable protocol. This is the protocol +that the @code{(guix inferior)} module speaks. +@end table +@item --listen=@var{extrémité} +By default, @command{guix repl} reads from standard input and writes to +standard output. When this option is passed, it will instead listen for +connections on @var{endpoint}. Here are examples of valid options: + +@table @code +@item --listen=tcp:37146 +Accept connections on localhost on port 37146. + +@item --listen=unix:/tmp/socket +Accept connections on the Unix-domain socket @file{/tmp/socket}. +@end table +@end table @c ********************************************************************* @node Utilitaires @@ -5728,11 +5881,11 @@ Guix d'une manière pratique. @cindex construction de paquets @cindex @command{guix build} -The @command{guix build} command builds packages or derivations and their -dependencies, and prints the resulting store paths. Note that it does not -modify the user's profile---this is the job of the @command{guix package} -command (@pxref{Invoquer guix package}). Thus, it is mainly useful for -distribution developers. +La commande @command{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 @command{guix package} (@pxref{Invoquer guix package}). Ainsi, +elle est surtout utile pour les développeurs de la distribution. La syntaxe générale est : @@ -5740,34 +5893,34 @@ La syntaxe générale est : guix build @var{options} @var{package-or-derivation}@dots{} @end example -As an example, the following command builds the latest versions of Emacs and -of Guile, displays their build logs, and finally displays the resulting -directories: +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 : @example guix build emacs guile @end example -Similarly, the following command builds all the available packages: +De même, la commande suivante construit tous les paquets disponibles : @example guix build --quiet --keep-going \ `guix package -A | cut -f1,2 --output-delimiter=@@` @end example -@var{package-or-derivation} may be either the name of a package found in the -software distribution such as @code{coreutils} or @code{coreutils@@8.20}, or -a derivation such as @file{/gnu/store/@dots{}-coreutils-8.19.drv}. In the -former case, a package with the corresponding name (and optionally version) -is searched for among the GNU distribution modules (@pxref{Modules de paquets}). +@var{package-or-derivation} peut être soit le nom d'un paquet trouvé dans la +distribution logicielle comme @code{coreutils}, soit @code{coreutils@@8.20}, +soit une dérivation comme @file{/gnu/store/@dots{}-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 (@pxref{Modules de paquets}). -Alternatively, the @code{--expression} option may be used to specify a -Scheme expression that evaluates to a package; this is useful when -disambiguating among several same-named packages or package variants is -needed. +Autrement, l'option @code{--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. -There may be zero or more @var{options}. The available options are -described in the subsections below. +Il peut y avoir aucune, une ou plusieurs @var{options}. Les options +disponibles sont décrites dans les sous-sections ci-dessous. @menu * Options de construction communes:: Options de construction pour la @@ -5781,56 +5934,60 @@ described in the subsections below. @node Options de construction communes @subsection Options de construction communes -A number of options that control the build process are common to -@command{guix build} and other commands that can spawn builds, such as -@command{guix package} or @command{guix archive}. These are the following: +Un certain nombre d'options qui contrôlent le processus de construction sont +communes avec @command{guix build} et les autres commandes qui peuvent +générer des constructions, comme @command{guix package} ou @command{guix +archive}. Voici ces options : @table @code -@item --load-path=@var{directory} -@itemx -L @var{directory} -Add @var{directory} to the front of the package module search path +@item --load-path=@var{répertoire} +@itemx -L @var{répertoire} +Ajoute @var{répertoire} au début du chemin de recherche de module de paquets (@pxref{Modules de paquets}). -This allows users to define their own packages and make them visible to the -command-line tools. +Cela permet à des utilisateurs de définir leur propres paquets et les rendre +disponibles aux outils en ligne de commande. @item --keep-failed @itemx -K -Keep the build tree of failed builds. Thus, if a build fails, its build -tree is kept under @file{/tmp}, in a directory whose name is shown at the -end of the build log. This is useful when debugging build issues. -@xref{Débogage des échecs de construction}, for tips and tricks on how to debug build -issues. +Garde l'arborescence de construction des constructions en échec. Ainsi, si +une construction échoue, son arborescence de construction est préservée dans +@file{/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. +@xref{Débogage des échecs de construction}, pour des astuces sur la manière de déboguer +des problèmes de construction. @item --keep-going @itemx -k -Keep going when some of the derivations fail to build; return only once all -the builds have either completed or failed. +Continue lorsque certaines dérivations échouent ; ne s'arrête que lorsque +toutes les constructions ont soit réussies, soit échouées. -The default behavior is to stop as soon as one of the specified derivations -has failed. +Le comportement par défaut est de s'arrêter dès qu'une des dérivations +spécifiées échoue. @item --dry-run @itemx -n -Do not build the derivations. +Ne pas construire les dérivations. -@anchor{fallback-option} +@anchor{option de repli} @item --fallback -When substituting a pre-built binary fails, fall back to building packages -locally (@pxref{Échec de substitution}). +Lorsque la substitution d'un binaire pré-compilé échoue, construit les +paquets localement à la place (@pxref{Échec de substitution}). @item --substitute-urls=@var{urls} @anchor{client-substitute-urls} -Consider @var{urls} the whitespace-separated list of substitute source URLs, -overriding the default list of URLs of @command{guix-daemon} -(@pxref{daemon-substitute-urls,, @command{guix-daemon} URLs}). +Considère @var{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 +@command{guix-daemon} (@pxref{daemon-substitute-urls,, @command{guix-daemon} +URLs}). Cela signifie que les substituts peuvent être téléchargés depuis @var{urls}, tant qu'ils sont signés par une clef autorisée par l'administrateur système (@pxref{Substituts}). -When @var{urls} is the empty string, substitutes are effectively disabled. +Lorsque @var{urls} est la chaîne vide, cela a pour effet de désactiver la +substitution. @item --no-substitutes Ne pas utiliser de substitut pour les résultats de la construction. @@ -5838,202 +5995,208 @@ C'est-à-dire, toujours construire localement plutôt que de permettre le téléchargement de binaires pré-construits (@pxref{Substituts}). @item --no-grafts -Do not ``graft'' packages. In practice, this means that package updates -available as grafts are not applied. @xref{Mises à jour de sécurité}, for more -information on 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. +@xref{Mises à jour de sécurité}, pour plus d'information sur les greffes. @item --rounds=@var{n} -Build each derivation @var{n} times in a row, and raise an error if -consecutive build results are not bit-for-bit identical. +Construit chaque dérivation @var{n} fois d'affilé, et renvoie une erreur si +les constructions consécutives ne sont pas identiques bit-à-bit. -This is a useful way to detect non-deterministic builds processes. -Non-deterministic build processes are a problem because they make it -practically impossible for users to @emph{verify} whether third-party -binaries are genuine. @xref{Invoquer guix challenge}, for more. +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 +@emph{vérification} par les utilisateurs de l'authenticité de binaires +tiers. @xref{Invoquer guix challenge}, pour plus d'informations. -Note that, currently, the differing build results are not kept around, so -you will have to manually investigate in case of an error---e.g., by -stashing one of the build results with @code{guix archive --export} -(@pxref{Invoquer guix archive}), then rebuilding, and finally comparing the -two results. +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 @code{guix archive --export} (@pxref{Invoquer guix archive}), +puis en reconstruisant, et enfin en comparant les deux résultats. @item --no-build-hook -Do not attempt to offload builds @i{via} the ``build hook'' of the daemon -(@pxref{Réglages du délestage du démon}). That is, always build things locally -instead of offloading builds to remote machines. +N'essaye pas de décharger les constructions via le « crochet de construction +» du démon (@pxref{Réglages du délestage du démon}). C'est-à-dire que tout sera +construit localement plutôt que de décharger les constructions à une machine +distante. @item --max-silent-time=@var{secondes} Lorsque le processus de construction ou de substitution restent silencieux pendant plus de @var{secondes}, le terminer et rapporter une erreur de construction. -By default, the daemon's setting is honored (@pxref{Invoquer guix-daemon, -@code{--max-silent-time}}). +Par défaut, les paramètres du démon sont pris en compte (@pxref{Invoquer guix-daemon, @code{--max-silent-time}}). @item --timeout=@var{secondes} De même, lorsque le processus de construction ou de substitution dure plus de @var{secondes}, le terminer et rapporter une erreur de construction. -By default, the daemon's setting is honored (@pxref{Invoquer guix-daemon, -@code{--timeout}}). +Par défaut, les paramètres du démon sont pris en compte (@pxref{Invoquer guix-daemon, @code{--timeout}}). @item --verbosity=@var{level} -Use the given verbosity level. @var{level} must be an integer between 0 and -5; higher means more verbose output. Setting a level of 4 or more may be -helpful when debugging setup issues with the build daemon. +Utilise le niveau de verbosité donné. @var{level} doit être un entier entre +0 et 5 ; les entiers les plus hauts signifient une sortie plus verbeuse. Le +mettre à 4 ou plus peut être utile pour déboguer des problèmes de +configuration du démon de construction. @item --cores=@var{n} @itemx -c @var{n} -Allow the use of up to @var{n} CPU cores for the build. The special value -@code{0} means to use as many CPU cores as available. +Permet d'utiliser jusqu'à @var{n} cœurs du CPU pour la construction. La +valeur spéciale @code{0} signifie autant de cœurs que possible. @item --max-jobs=@var{n} @itemx -M @var{n} -Allow at most @var{n} build jobs in parallel. @xref{Invoquer guix-daemon, -@code{--max-jobs}}, for details about this option and the equivalent -@command{guix-daemon} option. +Permet au plus @var{n} travaux de construction en parallèle. @xref{Invoquer guix-daemon, @code{--max-jobs}}, pour plus de détails sur cette option et +l'option équivalente pour @command{guix-daemon}. @end table -Behind the scenes, @command{guix build} is essentially an interface to the -@code{package-derivation} procedure of the @code{(guix packages)} module, -and to the @code{build-derivations} procedure of the @code{(guix -derivations)} module. +Sous le capot, @command{guix build} est surtout un interface à la procédure +@code{package-derivation} du module @code{(guix packages)}, et à la +procédure @code{build-derivations} du module @code{(guix derivations)}. -In addition to options explicitly passed on the command line, @command{guix -build} and other @command{guix} commands that support building honor the -@code{GUIX_BUILD_OPTIONS} environment variable. +En plus des options passées explicitement par la ligne de commande, +@command{guix build} et les autres commande @command{guix} qui peuvent +effectuer des construction honorent la variable d'environnement +@code{GUIX_BUILD_OPTIONS}. -@defvr {Environment Variable} GUIX_BUILD_OPTIONS -Users can define this variable to a list of command line options that will -automatically be used by @command{guix build} and other @command{guix} -commands that can perform builds, as in the example below: +@defvr {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 @command{guix +build} et les autres commandes @command{guix} qui peuvent effectuer des +constructions, comme dans l'exemple suivant : @example $ export GUIX_BUILD_OPTIONS="--no-substitutes -c 2 -L /foo/bar" @end example -These options are parsed independently, and the result is appended to the -parsed command-line options. +Ces options sont analysées indépendamment, et le résultat est ajouté aux +options de la ligne de commande analysées. @end defvr @node Options de transformation de paquets @subsection Options de transformation de paquets -@cindex package variants -Another set of command-line options supported by @command{guix build} and -also @command{guix package} are @dfn{package transformation options}. These -are options that make it possible to define @dfn{package variants}---for -instance, packages built from different source code. This is a convenient -way to create customized packages on the fly without having to type in the -definitions of package variants (@pxref{Définition des paquets}). +@cindex variantes de paquets +Un autre ensemble d'options de la ligne de commande supportés par +@command{guix build} et aussi @command{guix package} sont les @dfn{options +de transformation de paquets}. Ce sont des options qui rendent possible la +définition de @dfn{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 (@pxref{Définition des paquets}). @table @code @item --with-source=@var{source} -@itemx --with-source=@var{package}=@var{source} -@itemx --with-source=@var{package}@@@var{version}=@var{source} -Use @var{source} as the source of @var{package}, and @var{version} as its -version number. @var{source} must be a file name or a URL, as for -@command{guix download} (@pxref{Invoquer guix download}). +@itemx --with-source=@var{paquet}=@var{source} +@itemx --with-source=@var{paquet}@@@var{version}=@var{source} +Utiles @var{source} comme la source de @var{paquet}, et @var{version} comme +son numéro de version. @var{source} doit être un nom de fichier ou une URL, +comme pour @command{guix download} (@pxref{Invoquer guix download}). -When @var{package} is omitted, it is taken to be the package name specified -on the command line that matches the base of @var{source}---e.g., if -@var{source} is @code{/src/guile-2.0.10.tar.gz}, the corresponding package -is @code{guile}. +Lorsque @var{paquet} est omis, la commande utilisera le nom de paquet +spécifié par la base de @var{source} — p.@: ex.@: si @var{source} est +@code{/src/guix-2.0.10.tar.gz}, le paquet correspondant est @code{guile}. -Likewise, when @var{version} is omitted, the version string is inferred from -@var{source}; in the previous example, it is @code{2.0.10}. +De même, lorsque @var{version} est omis, la chaîne de version est inférée à +partir de @var{source} ; dans l'exemple précédent, il s'agit de +@code{2.0.10}. -This option allows users to try out versions of packages other than the one -provided by the distribution. The example below downloads -@file{ed-1.7.tar.gz} from a GNU mirror and uses that as the source for the -@code{ed} package: +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 @file{ed-1.7.tar.g} depuis un mirroir GNU et l'utilise comme +source pour le paquet @code{ed} : @example guix build ed --with-source=mirror://gnu/ed/ed-1.7.tar.gz @end example -As a developer, @code{--with-source} makes it easy to test release -candidates: +En tant que développeur, @code{--with-source} permet de tester facilement +des version bêta : @example guix build guile --with-source=../guile-2.0.9.219-e1bb7.tar.xz @end example -@dots{} or to build from a checkout in a pristine environment: +@dots{} ou pour construire un dépôt de gestion de version dans un +environnement vierge : @example $ git clone git://git.sv.gnu.org/guix.git $ guix build guix --with-source=guix@@1.0=./guix @end example -@item --with-input=@var{package}=@var{replacement} -Replace dependency on @var{package} by a dependency on @var{replacement}. -@var{package} must be a package name, and @var{replacement} must be a -package specification such as @code{guile} or @code{guile@@1.8}. +@item --with-input=@var{paquet}=@var{remplaçant} +Remplace la dépendance sur @var{paquet} par une dépendance à +@var{remplaçant}. @var{paquet} doit être un nom de paquet et +@var{remplaçant} doit être une spécification de paquet comme @code{guile} ou +@code{guile@@1.8}. -For instance, the following command builds Guix, but replaces its dependency -on the current stable version of Guile with a dependency on the legacy -version of Guile, @code{guile@@2.0}: +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, @code{guile@@2.0} : @example guix build --with-input=guile=guile@@2.0 guix @end example -This is a recursive, deep replacement. So in this example, both @code{guix} -and its dependency @code{guile-json} (which also depends on @code{guile}) -get rebuilt against @code{guile@@2.0}. +C'est un remplacement récursif profond. Donc dans cet exemple, à la fois +@code{guix} et ses dépendances @code{guile-json} (qui dépend aussi de +@code{guile}) sont reconstruits avec @code{guile@@2.0}. -This is implemented using the @code{package-input-rewriting} Scheme -procedure (@pxref{Définition des paquets, @code{package-input-rewriting}}). +Cette option est implémentée avec la procédure Scheme +@code{package-input-rewriting} (@pxref{Définition des paquets, +@code{package-input-rewriting}}). -@item --with-graft=@var{package}=@var{replacement} -This is similar to @code{--with-input} but with an important difference: -instead of rebuilding the whole dependency chain, @var{replacement} is built -and then @dfn{grafted} onto the binaries that were initially referring to -@var{package}. @xref{Mises à jour de sécurité}, for more information on grafts. +@item --with-graft=@var{paquet}=@var{remplaçant} +Cette option est similaire à @code{--with-input} mais avec une différence +importante : plutôt que de reconstruire la chaîne de dépendance complète, +@var{remplaçant} est construit puis @dfn{greffé} sur les binaires qui +référençaient initialement @var{paquet}. @xref{Mises à jour de sécurité}, pour plus +d'information sur les greffes. -For example, the command below grafts version 3.5.4 of GnuTLS onto Wget and -all its dependencies, replacing references to the version of GnuTLS they -currently refer to: +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 : @example guix build --with-graft=gnutls=gnutls@@3.5.4 wget @end example -This has the advantage of being much faster than rebuilding everything. But -there is a caveat: it works if and only if @var{package} and -@var{replacement} are strictly compatible---for example, if they provide a -library, the application binary interface (ABI) of those libraries must be -compatible. If @var{replacement} is somehow incompatible with -@var{package}, then the resulting package may be unusable. Use with care! +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 @var{paquet} et @var{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 @var{remplaçant} est incompatible avec +@var{paquet}, alors le paquet qui en résulte peut devenir inutilisable. À +utilisez avec précaution ! @end table @node Options de construction supplémentaires @subsection Options de construction supplémentaires -The command-line options presented below are specific to @command{guix -build}. +Les options de la ligne de commande ci-dessous sont spécifiques à +@command{guix build}. @table @code @item --quiet @itemx -q -Build quietly, without displaying the build log. Upon completion, the build -log is kept in @file{/var} (or similar) and can always be retrieved using -the @option{--log-file} option. +Construire en silence, sans afficher les journaux de construction. À la +fin, le journal de construction est gardé dans @file{/var} (ou similaire) et +on peut toujours l'y trouver avec l'option @option{--log-file}. -@item --file=@var{file} +@item --file=@var{fichier} @itemx -f @var{fichier} -Build the package or derivation that the code within @var{file} evaluates -to. +Construit le paquet ou la dérivation en lequel le code dans @var{file} +s'évalue. -As an example, @var{file} might contain a package definition like this -(@pxref{Définition des paquets}): +Par exemple, @var{file} peut contenir une définition de paquet comme ceci +(@pxref{Définition des paquets}) : @example @verbatiminclude package-hello.scm @@ -6041,47 +6204,50 @@ As an example, @var{file} might contain a package definition like this @item --expression=@var{expr} @itemx -e @var{expr} -Build the package or derivation @var{expr} evaluates to. +Construit le paquet ou la dérivation en lequel @var{expr} s'évalue. -For example, @var{expr} may be @code{(@@ (gnu packages guile) guile-1.8)}, -which unambiguously designates this specific variant of version 1.8 of -Guile. +Par exemple, @var{expr} peut être @code{(@@ (gnu packages guile) +guile-1.8)}, qui désigne sans ambiguïté cette variante spécifique de la +version 1.8 de Guile. -Alternatively, @var{expr} may be a G-expression, in which case it is used as -a build program passed to @code{gexp->derivation} (@pxref{G-Expressions}). +Autrement, @var{exp} peut être une G-expression, auquel cas elle est +utilisée comme un programme de construction passé à @code{gexp->derivation} +(@pxref{G-Expressions}). -Lastly, @var{expr} may refer to a zero-argument monadic procedure -(@pxref{La monad du dépôt}). The procedure must return a derivation as a -monadic value, which is then passed through @code{run-with-store}. +Enfin, @var{expr} peut se référer à une procédure monadique à au moins un +argument (@pxref{La monad du dépôt}). La procédure doit renvoyer une +dérivation comme une valeur monadique, qui est ensuite lancée à travers +@code{run-with-store}. @item --source @itemx -S -Build the source derivations of the packages, rather than the packages -themselves. +Construit les dérivation source des paquets, plutôt que des paquets +eux-même. -For instance, @code{guix build -S gcc} returns something like -@file{/gnu/store/@dots{}-gcc-4.7.2.tar.bz2}, which is the GCC source -tarball. +Par exemple, @code{guix build -S gcc} renvoie quelque chose comme +@file{/gnu/store/@dots{}-gcc-4.7.2.tar.bz2}, qui est l'archive des sources +de GCC. -The returned source tarball is the result of applying any patches and code -snippets specified in the package @code{origin} (@pxref{Définition des paquets}). +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 +@code{origin} du paquet (@pxref{Définition des paquets}). @item --sources -Fetch and return the source of @var{package-or-derivation} and all their -dependencies, recursively. This is a handy way to obtain a local copy of -all the source code needed to build @var{packages}, allowing you to -eventually build them even without network access. It is an extension of -the @code{--source} option and can accept one of the following optional -argument values: +Récupère et renvoie la source de @var{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 @var{packages}, ce qui vous +permet de les construire plus tard même sans accès réseau. C'est une +extension de l'option @code{--source} et peut accepter l'un des arguments +facultatifs suivants : @table @code @item package -This value causes the @code{--sources} option to behave in the same way as -the @code{--source} option. +Cette valeur fait que l'option @code{--sources} se comporte comme l'option +@code{--source}. @item all -Build the source derivations of all packages, including any source that -might be listed as @code{inputs}. This is the default value. +Construit les dérivations des sources de tous les paquets, dont les sources +qui pourraient être listées dans @code{inputs}. C'est la valeur par défaut. @example $ guix build --sources tzdata @@ -6091,9 +6257,10 @@ The following derivations will be built: @end example @item transitive -Build the source derivations of all packages, as well of all transitive -inputs to the packages. This can be used e.g. to prefetch package source -for later offline building. +Construit les dérivations des sources de tous les paquets, ainsi que toutes +celles les entrées transitives des paquets. On peut utiliser cette option +pour précharger les sources des paquets pour les construire plus tard hors +ligne par exemple. @example $ guix build --sources=transitive tzdata @@ -6115,30 +6282,33 @@ Tenter de construire pour le @var{système} — p.@: ex.@: @code{i686-linux} — plutôt que pour le type de système de l'hôte de construction. @quotation Remarque -The @code{--system} flag is for @emph{native} compilation and must not be -confused with cross-compilation. See @code{--target} below for information -on cross-compilation. +Le drapeau @code{--system} est utilisé pour une compilation @emph{native} et +ne doit pas être confondu avec une compilation croisée. Voir +@code{--target} ci-dessous pour des informations sur la compilation croisée. @end quotation -An example use of this is on Linux-based systems, which can emulate -different personalities. For instance, passing @code{--system=i686-linux} -on an @code{x86_64-linux} system or @code{--system=armhf-linux} on an -@code{aarch64-linux} system allows you to build packages in a complete -32-bit environment. +Par exemple, passer @code{--system=i686-linux} sur un système +@code{x86_64-linux} ou @code{--system=armhf-linux} sur un système +@code{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. @quotation Remarque -Building for an @code{armhf-linux} system is unconditionally enabled on -@code{aarch64-linux} machines, although certain aarch64 chipsets do not -allow for this functionality, notably the ThunderX. +La possibilité de construire pour un système @code{armhf-linux} est activé +sans condition sur les machines @code{aarch64-linux}, bien que certaines +puces aarch64 n'en soient pas capables, comme les ThunderX. @end quotation -Similarly, when transparent emulation with QEMU and @code{binfmt_misc} is -enabled (@pxref{Services de virtualisation, @code{qemu-binfmt-service-type}}), -you can build for any system for which a QEMU @code{binfmt_misc} handler is -installed. +De même, lorsque l'émulation transparente avec QEMU et @code{binfnmt_misc} +est activée (@pxref{Services de virtualisation, +@code{qemu-binfmt-service-type}}), vous pouvez construire pour n'importe +quel système pour lequel un gestionnaire QEMU @code{binfmt_misc} est +installé. -Builds for a system other than that of the machine you are using can also be -offloaded to a remote machine of the right architecture. @xref{Réglages du délestage du démon}, for more information on offloading. +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. @xref{Réglages du délestage du démon}, pour plus d'information sur le +déchargement. @item --target=@var{triplet} @cindex compilation croisée @@ -6146,13 +6316,13 @@ Effectuer une compilation croisée pour @var{triplet} qui doit être un triplet GNU valide, comme @code{"mips64el-linux-gnu"} (@pxref{Specifying target triplets, GNU configuration triplets,, autoconf, Autoconf}). -@anchor{build-check} +@anchor{vérification de la construction} @item --check @cindex déterminisme, vérification @cindex reproductibilité, vérification -Rebuild @var{package-or-derivation}, which are already available in the -store, and raise an error if the build results are not bit-for-bit -identical. +Reconstruit les @var{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 (@pxref{Substituts}) ou si le résultat de la @@ -6164,36 +6334,40 @@ dans le dépôt sous @file{/gnu/store/@dots{}-check}. Cela rend plus facile l'étude des différences entre les deux résultats. @item --repair -@cindex repairing store items +@cindex réparer les éléments du dépôt @cindex corruption, récupérer de -Attempt to repair the specified store items, if they are corrupt, by -re-downloading or rebuilding them. +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. -This operation is not atomic and thus restricted to @code{root}. +Cette opération n'est pas atomique et donc restreinte à l'utilisateur +@code{root} @item --derivations @itemx -d -Return the derivation paths, not the output paths, of the given packages. +Renvoie les chemins de dérivation, et non les chemins de sortie, des paquets +donnés. -@item --root=@var{file} -@itemx -r @var{file} -@cindex GC roots, adding -@cindex garbage collector roots, adding -Make @var{file} a symlink to the result, and register it as a garbage -collector root. +@item --root=@var{fichier} +@itemx -r @var{fichier} +@cindex racines du GC, ajout +@cindex ajout de racines au ramasse-miettes +Fait de @var{fichier} un lien symbolique vers le résultat, et l'enregistre +en tant que racine du ramasse-miettes. -Consequently, the results of this @command{guix build} invocation are -protected from garbage collection until @var{file} is removed. When that -option is omitted, build results are eligible for garbage collection as soon -as the build completes. @xref{Invoquer guix gc}, for more on GC roots. +En conséquence, les résultats de cette invocation de @command{guix build} +sont protégés du ramasse-miettes jusqu'à ce que @var{fichier} soit +supprimé. Lorsque cette option est omise, les constructions sont +susceptibles d'être glanées. @item --log-file -@cindex build logs, access -Return the build log file names or URLs for the given -@var{package-or-derivation}, or raise an error if build logs are missing. +@cindex journaux de construction, accès +Renvoie les noms des journaux de construction ou les URL des +@var{package-or-derivation} donnés ou lève une erreur si les journaux de +construction sont absents. -This works regardless of how packages or derivations are specified. For -instance, the following invocations are equivalent: +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 : @example guix build --log-file `guix build -d guile` @@ -6202,40 +6376,44 @@ guix build --log-file guile guix build --log-file -e '(@@ (gnu packages guile) guile-2.0)' @end example -If a log is unavailable locally, and unless @code{--no-substitutes} is -passed, the command looks for a corresponding log on one of the substitute -servers (as specified with @code{--substitute-urls}.) +Si un journal n'est pas disponible localement, à moins que +@code{--no-substitutes} ne soit passé, la commande cherche un journal +correspondant sur l'un des serveurs de substituts (tels que spécifiés avec +@code{--substitute-urls}.) -So for instance, imagine you want to see the build log of GDB on MIPS, but -you are actually on an @code{x86_64} machine: +Donc par exemple, imaginons que vous souhaitiez voir le journal de +construction de GDB sur MIPS, mais que vous n'avez qu'une machine +@code{x86_64} : @example $ guix build --log-file gdb -s mips64el-linux https://hydra.gnu.org/log/@dots{}-gdb-7.10 @end example -You can freely access a huge library of build logs! +Vous pouvez accéder librement à un vaste bibliothèque de journaux de +construction ! @end table @node Débogage des échecs de construction @subsection Débogage des échecs de construction -@cindex build failures, debugging -When defining a new package (@pxref{Définition des paquets}), you will probably -find yourself spending some time debugging and tweaking the build until it -succeeds. To do that, you need to operate the build commands yourself in an -environment as close as possible to the one the build daemon uses. +@cindex échecs de construction, débogage +Lors de la définition d'un nouveau paquet (@pxref{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. -To that end, the first thing to do is to use the @option{--keep-failed} or -@option{-K} option of @command{guix build}, which will keep the failed build -tree in @file{/tmp} or whatever directory you specified as @code{TMPDIR} -(@pxref{Invoquer guix build, @code{--keep-failed}}). +Pour cela, la première chose à faire est d'utiliser l'option +@option{--keep-failed} ou @option{-K} de @command{guix build}, qui gardera +l'arborescence de construction dans @file{/tmp} ou le répertoire spécifié +par @code{TMPDIR} (@pxref{Invoquer guix build, @code{--keep-failed}}). -From there on, you can @command{cd} to the failed build tree and source the -@file{environment-variables} file, which contains all the environment -variable definitions that were in place when the build failed. So let's say -you're debugging a build failure in package @code{foo}; a typical session -would look like this: +À partir de là, vous pouvez vous déplacer dans l'arborescence de +construction et sourcer le fichier @file{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 @code{foo} ; une session typique ressemblerait à cela : @example $ guix build foo -K @@ -6245,17 +6423,17 @@ $ source ./environment-variables $ cd foo-1.2 @end example -Now, you can invoke commands as if you were the daemon (almost) and -troubleshoot your build process. +Maintenant, vous pouvez invoquer les commandes comme si vous étiez le démon +(presque) et corriger le processus de construction. -Sometimes it happens that, for example, a package's tests pass when you run -them manually but they fail when the daemon runs them. This can happen -because the daemon runs builds in containers where, unlike in our -environment above, network access is missing, @file{/bin/sh} does not exist, -etc. (@pxref{Réglages de l'environnement 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, @file{/bin/sh} n'existe pas, etc (@pxref{Réglages de l'environnement de construction}). -In such cases, you may need to run inspect the build process from within a -container similar to the one the build daemon creates: +Dans ce cas, vous pourriez avoir besoin de lancer le processus de +construction dans un conteneur similaire à celui que le démon crée : @example $ guix build -K foo @@ -6266,162 +6444,168 @@ $ guix environment --no-grafts -C foo --ad-hoc strace gdb [env]# cd foo-1.2 @end example -Here, @command{guix environment -C} creates a container and spawns a new -shell in it (@pxref{Invoquer guix environment}). The @command{--ad-hoc -strace gdb} part adds the @command{strace} and @command{gdb} commands to the -container, which would may find handy while debugging. The -@option{--no-grafts} option makes sure we get the exact same environment, -with ungrafted packages (@pxref{Mises à jour de sécurité}, for more info on grafts). +Ici, @command{guix environment -C} crée un conteneur et démarre un nouveau +shell dedans (@pxref{Invoquer guix environment}). La partie +@command{--ad-hoc strace gdb} ajoute les commandes @command{strace} et +@command{gdb} dans le conteneur, ce qui pourrait s'avérer utile pour le +débogage. L'option @option{--no-grafts} s'assure qu'on obtient le même +environnement, avec des paquets non greffés (@pxref{Mises à jour de sécurité}, pour +plus d'informations sur les greffes). -To get closer to a container like that used by the build daemon, we can -remove @file{/bin/sh}: +Pour obtenir un conteneur plus proche de ce qui serait utilisé par le démon +de construction, on peut enlever @file{/bin/sh} : @example [env]# rm /bin/sh @end example -(Don't worry, this is harmless: this is all happening in the throw-away -container created by @command{guix environment}.) +Ne vous inquiétez pas, c'est sans danger : tout cela se passe dans un +conteneur jetable créé par @command{guix environment}. -The @command{strace} command is probably not in the search path, but we can -run: +La commande @command{strace} n'est probablement pas dans le chemin de +recherche, mais on peut lancer : @example [env]# $GUIX_ENVIRONMENT/bin/strace -f -o log make check @end example -In this way, not only you will have reproduced the environment variables the -daemon uses, you will also be running the build process in a container -similar to the one the daemon uses. +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. @node Invoquer guix edit -@section Invoking @command{guix edit} +@section Invoquer @command{guix edit} @cindex @command{guix edit} -@cindex package definition, editing -So many packages, so many source files! The @command{guix edit} command -facilitates the life of users and packagers by pointing their editor at the -source file containing the definition of the specified packages. For -instance: +@cindex définition de paquets, modification +Tant de paquets, tant de fichiers source ! La commande @command{guix edit} +facilite la vie des utilisateurs et des packagers en plaçant leur éditeur +sur le fichier source qui contient la définition des paquets spécifiés. Par +exemple : @example guix edit gcc@@4.9 vim @end example @noindent -launches the program specified in the @code{VISUAL} or in the @code{EDITOR} -environment variable to view the recipe of GCC@tie{}4.9.3 and that of Vim. +lance le programme spécifié dans la variable d'environnement @code{VISUAL} +ou @code{EDITOR} pour visionner la recette de GCC@tie{}4.9.3 et cele de Vim. -If you are using a Guix Git checkout (@pxref{Construire depuis Git}), or have -created your own packages on @code{GUIX_PACKAGE_PATH} (@pxref{Définition des paquets}), you will be able to edit the package recipes. Otherwise, you -will be able to examine the read-only recipes for packages currently in the -store. +Si vous utilisez une copie du dépôt Git de Guix (@pxref{Construire depuis Git}), +ou que vous avez créé vos propres paquets dans @code{GUIX_PACKAGE_PATH} +(@pxref{Définition des 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. @node Invoquer guix download -@section Invoking @command{guix download} +@section Invoquer @command{guix download} @cindex @command{guix download} -@cindex downloading package sources -When writing a package definition, developers typically need to download a -source tarball, compute its SHA256 hash, and write that hash in the package -definition (@pxref{Définition des paquets}). The @command{guix download} tool -helps with this task: it downloads a file from the given URI, adds it to the -store, and prints both its file name in the store and its SHA256 hash. - -The fact that the downloaded file is added to the store saves bandwidth: -when the developer eventually tries to build the newly defined package with -@command{guix build}, the source tarball will not have to be downloaded -again because it is already in the store. It is also a convenient way to -temporarily stash files, which may be deleted eventually (@pxref{Invoquer guix gc}). - -The @command{guix download} command supports the same URIs as used in -package definitions. In particular, it supports @code{mirror://} URIs. -@code{https} URIs (HTTP over TLS) are supported @emph{provided} the Guile -bindings for GnuTLS are available in the user's environment; when they are -not available, an error is raised. @xref{Guile Preparations, how to install -the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}, for more -information. - -@command{guix download} verifies HTTPS server certificates by loading the -certificates of X.509 authorities from the directory pointed to by the -@code{SSL_CERT_DIR} environment variable (@pxref{Certificats X.509}), -unless @option{--no-check-certificate} is used. - -The following options are available: +@cindex télécharger les sources des paquets +En écrivant des définitions de paquets, les développeurs ont 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 (@pxref{Définition des paquets}). +L'outil @command{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 préserve la bande +passante : losque les développeurs finissent par construire le paquet +nouvellement défini avec @command{guix build}, l'archive des sources n'aura +pas besoin d'être téléchargée de nouveau puisqu'elle se trouvera 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 (@pxref{Invoquer guix gc}). + +La commande @command{guix download} supporte les mêmes URI que celles +utilisées dans les définitions de paquets. En particulier, elle supporte +les URI @code {mirror://}. Les URI @code{http} (HTTP sur TLS) sont +supportées @emph{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. @xref{Guile Preparations, how to install the GnuTLS +bindings for Guile,, gnutls-guile, GnuTLS-Guile}, pour plus d'informations. + +@command{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 @code{SSL_CERT_DIR} (@pxref{Certificats X.509}), à moins que @option{--no-check-certificate} ne soit utilisé. + +Les options suivantes sont disponibles : @table @code @item --format=@var{fmt} @itemx -f @var{fmt} -Write the hash in the format specified by @var{fmt}. For more information -on the valid values for @var{fmt}, @pxref{Invoquer guix hash}. +Écrit le hash dans le format spécifié par @var{fmt}. Pour plus +d'informations sur les valeurs valides pour @var{fmt}, @pxref{Invoquer guix hash}. @item --no-check-certificate -Do not validate the X.509 certificates of HTTPS servers. +Ne pas valider les certificats HTTPS des serveurs. -When using this option, you have @emph{absolutely no guarantee} that you are -communicating with the authentic server responsible for the given URL, which -makes you vulnerable to ``man-in-the-middle'' attacks. +Lorsque vous utilisez cette option, vous n'avez @emph{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 ». -@item --output=@var{file} -@itemx -o @var{file} -Save the downloaded file to @var{file} instead of adding it to the store. +@item --output=@var{fichier} +@itemx -o @var{fichier} +Enregistre le fichier téléchargé dans @var{fichier} plutôt que de l'ajouter +au dépôt. @end table @node Invoquer guix hash -@section Invoking @command{guix hash} +@section Invoquer @command{guix hash} @cindex @command{guix hash} -The @command{guix hash} command computes the SHA256 hash of a file. It is -primarily a convenience tool for anyone contributing to the distribution: it -computes the cryptographic hash of a file, which can be used in the -definition of a package (@pxref{Définition des paquets}). +La commande @command{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 (@pxref{Définition des paquets}). La syntaxe générale est : @example -guix hash @var{option} @var{file} +guix hash @var{option} @var{fichier} @end example -When @var{file} is @code{-} (a hyphen), @command{guix hash} computes the -hash of data read from standard input. @command{guix hash} has the -following options: +Lorsque @var{fichier} est @code{-} (un tiret), @command{guix hash} calcul le +hash des données lues depuis l'entrée standard. @command{guix hash} a les +options suivantes : @table @code @item --format=@var{fmt} @itemx -f @var{fmt} -Write the hash in the format specified by @var{fmt}. +Écrit le hash dans le format spécifié par @var{fmt}. -Supported formats: @code{nix-base32}, @code{base32}, @code{base16} -(@code{hex} and @code{hexadecimal} can be used as well). +Les formats supportés sont : @code{nix-base32}, @code{base32}, @code{base16} +(@code{hex} et @code{hexadecimal} peuvent aussi être utilisés). -If the @option{--format} option is not specified, @command{guix hash} will -output the hash in @code{nix-base32}. This representation is used in the -definitions of packages. +Si l'option @option {--format} n'est pas spécifiée, @command{guix hash} +affichera le hash en @code{nix-base32}. Cette représentation est utilisée +dans les définitions des paquets. @item --recursive @itemx -r -Compute the hash on @var{file} recursively. +Calcule le hash sur @var{fichier} récursivement. @c FIXME: Replace xref above with xref to an ``Archive'' section when @c it exists. -In this case, the hash is computed on an archive containing @var{file}, -including its children if it is a directory. Some of the metadata of -@var{file} is part of the archive; for instance, when @var{file} is a -regular file, the hash is different depending on whether @var{file} is -executable or not. Metadata such as time stamps has no impact on the hash -(@pxref{Invoquer guix archive}). +Dans ce cas, le hash est calculé sur une archive contenant @var{fichier}, +dont ses enfants si c'est un répertoire. Certaines métadonnées de +@var{fichier} fait partie de l'archive ; par exemple lorsque @var{fichier} +est un fichier normal, le hash est différent que le @var{fichier} soit +exécutable ou non. Les métadonnées comme un horodatage n'ont aucun impact +sur le hash (@pxref{Invoquer guix archive}). @item --exclude-vcs @itemx -x -When combined with @option{--recursive}, exclude version control system -directories (@file{.bzr}, @file{.git}, @file{.hg}, etc.) +Lorsqu'elle est combinée à @option{--recursive}, exclut les répertoires de +système de contrôle de version (@file{.bzr}, @file{.git}, @file{.hg}, etc). @vindex git-fetch -As an example, here is how you would compute the hash of a Git checkout, -which is useful when using the @code{git-fetch} method (@pxref{Référence d'origine}): +Par exemple, voici comment calculer le hash d'un dépôt Git, ce qui est utile +avec la méthode @code{git-fetch} (@pxref{Référence d'origine}) : @example $ git clone http://example.org/foo.git @@ -6431,17 +6615,18 @@ $ guix hash -rx . @end table @node Invoquer guix import -@section Invoking @command{guix import} - -@cindex importing packages -@cindex package import -@cindex package conversion -@cindex Invoking @command{guix import} -The @command{guix import} command is useful for people who would like to add -a package to the distribution with as little work as possible---a legitimate -demand. The command knows of a few repositories from which it can -``import'' package metadata. The result is a package definition, or a -template thereof, in the format we know (@pxref{Définition des paquets}). +@section Invoquer @command{guix import} + +@cindex importer des paquets +@cindex paquets importés +@cindex conversion de paquets +@cindex Invoquer @command{guix import} +La commande @command{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 (@pxref{Définition des paquets}). La syntaxe générale est : @@ -6449,47 +6634,49 @@ La syntaxe générale est : guix import @var{importer} @var{options}@dots{} @end example -@var{importer} specifies the source from which to import package metadata, -and @var{options} specifies a package identifier and other options specific -to @var{importer}. Currently, the available ``importers'' are: +@var{importer} spécifie la source depuis laquelle importer des métadonnées +de paquets, et @var{options} spécifie un identifiant de paquet et d'autres +options spécifiques à @var{importer}. Actuellement les « importateurs » +disponibles sont : @table @code @item gnu -Import metadata for the given GNU package. This provides a template for the -latest version of that GNU package, including the hash of its source -tarball, and its canonical synopsis and description. +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. -Additional information such as the package dependencies and its license -needs to be figured out manually. +Les informations supplémentaires comme les dépendances du paquet et sa +licence doivent être renseignées manuellement. -For example, the following command returns a package definition for -GNU@tie{}Hello: +Par exemple, la commande suivante renvoie une définition de paquets pour +GNU@tie{}Hello : @example guix import gnu hello @end example -Specific command-line options are: +Les options spécifiques sont : @table @code -@item --key-download=@var{policy} -As for @code{guix refresh}, specify the policy to handle missing OpenPGP -keys when verifying the package signature. @xref{Invoquer guix refresh, -@code{--key-download}}. +@item --key-download=@var{politique} +Comme pour @code{guix refresh}, spécifie la politique de gestion des clefs +OpenPGP manquantes lors de la vérification de la signature d'un paquet. +@xref{Invoquer guix refresh, @code{--key-download}}. @end table @item pypi @cindex pypi -Import metadata from the @uref{https://pypi.python.org/, Python Package -Index}@footnote{This functionality requires Guile-JSON to be installed. -@xref{Prérequis}.}. Information is taken from the JSON-formatted -description available at @code{pypi.python.org} and usually includes all the -relevant information, including package dependencies. For maximum -efficiency, it is recommended to install the @command{unzip} utility, so -that the importer can unzip Python wheels and gather data from them. +Importe des métadonnées depuis @uref{https://pypi.python.org/, l'index des +paquets Python}@footnote{Cette fonctionnalité requiert l'installation de +Guile-JSON. @xref{Prérequis}.}. Les informations sont récupérées à +partir de la description en JSON disponible sur @code{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 @command{unzip}, pour que l'importateur puisse dézipper les +wheels Python et récupérer les informations contenues à l'intérieur. -The command below imports metadata for the @code{itsdangerous} Python -package: +La commande ci-dessous importe les métadonnées du paquet Python +@code{itsdangerous} : @example guix import pypi itsdangerous @@ -6497,35 +6684,44 @@ guix import pypi itsdangerous @item gem @cindex gem -Import metadata from @uref{https://rubygems.org/, RubyGems}@footnote{This -functionality requires Guile-JSON to be installed. @xref{Prérequis}.}. -Information is taken from the JSON-formatted description available at -@code{rubygems.org} and includes most relevant information, including -runtime dependencies. There are some caveats, however. The metadata -doesn't distinguish between synopses and descriptions, so the same string is -used for both fields. Additionally, the details of non-Ruby dependencies -required to build native extensions is unavailable and left as an exercise -to the packager. +Importe des métadonnées de @uref{https://rubygems.org/, +RubyGems}@footnote{Cette fonctionnalité requiert l'installation de +Guile-JSON. @xref{Prérequis}.}. Les informations sont récupérées au +format JSON disponible sur @code{rubygems.org} et inclut les informations +les plus utiles, comme les dépendances à l'exécution. Il y a des pièges +cependant. 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 au packager. -The command below imports metadata for the @code{rails} Ruby package: +La commande ci-dessous importe les métadonnées pour le paquet Ruby +@code{rails} : @example guix import gem rails @end example +@table @code +@item --recursive +@itemx -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. +@end table + @item cpan @cindex CPAN -Import metadata from @uref{https://www.metacpan.org/, -MetaCPAN}@footnote{This functionality requires Guile-JSON to be installed. -@xref{Prérequis}.}. Information is taken from the JSON-formatted -metadata provided through @uref{https://fastapi.metacpan.org/, MetaCPAN's -API} and includes most relevant information, such as module dependencies. -License information should be checked closely. If Perl is available in the -store, then the @code{corelist} utility will be used to filter core modules -out of the list of dependencies. +Importe des métadonnées de @uref{https://www.metacpan.org/, +MetaCPAN}@footnote{Cette fonctionnalité requiert l'installation de +Guile-JSON. @xref{Prérequis}.}. Les informations sont récupérées au +format JSON disponible à travers @uref{https://fastapi.metacpan.org/, 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 +@code{corelist} sera utiliser pour exclure les modules du cœur de la +distribution Perl de la liste des dépendances. -The command command below imports metadata for the @code{Acme::Boolean} Perl -module: +La commande ci-dessous importe les métadonnées du module Perl +@code{Acme::Boolean} : @example guix import cpan Acme::Boolean @@ -6534,31 +6730,32 @@ guix import cpan Acme::Boolean @item cran @cindex CRAN @cindex Bioconductor -Import metadata from @uref{https://cran.r-project.org/, CRAN}, the central -repository for the @uref{http://r-project.org, GNU@tie{}R statistical and -graphical environment}. +Importe des métadonnées de @uref{https://cran.r-project.org/, CRAN}, le +dépôt central de @uref{http://r-project.org, l'environnement statistique et +graphique GUN@tie{}R}. -Information is extracted from the @code{DESCRIPTION} file of the package. +Les informations sont extraites du fichier @file{DESCRIPTION} du paquet. -The command command below imports metadata for the @code{Cairo} R package: +La commande ci-dessous importe les métadonnées du paquet R @code{Cairo} : @example guix import cran Cairo @end example -When @code{--recursive} is added, the importer will traverse the dependency -graph of the given upstream package recursively and generate package -expressions for all those packages that are not yet in Guix. +Lorsque l'option @code{--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. -When @code{--archive=bioconductor} is added, metadata is imported from -@uref{https://www.bioconductor.org/, Bioconductor}, a repository of R -packages for for the analysis and comprehension of high-throughput genomic -data in bioinformatics. +Lorsque l'option @code{--archive=bioconductor} est utilisée, les métadonnées +sont importées de @uref{https://www.bioconductor.org/, 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 @code{DESCRIPTION} file of a package -published on the web interface of the Bioconductor SVN repository. +Les informations sont extraites du fichier @file{DESCRIPTION} d'un paquet +publié sur l'interface web du dépôt SVN de Bioconductor. -The command below imports metadata for the @code{GenomicRanges} R package: +La commande ci-dessous importe les métadonnées du paquet R +@code{GenomicRanges} : @example guix import cran --archive=bioconductor GenomicRanges @@ -6567,29 +6764,30 @@ guix import cran --archive=bioconductor GenomicRanges @item texlive @cindex TeX Live @cindex CTAN -Import metadata from @uref{http://www.ctan.org/, CTAN}, the comprehensive -TeX archive network for TeX packages that are part of the -@uref{https://www.tug.org/texlive/, TeX Live distribution}. +Importe les métadonnées de @uref{http://www.ctan.org/, CTAN}, l'archive TeX +réseau complète pour les paquets TeX qui font partie de la +@uref{https://www.tug.org/texlive/, distribution TeX Live}. -Information about the package is obtained through the XML API provided by -CTAN, while the source code is downloaded from the SVN repository of the Tex -Live project. This is done because the CTAN does not keep versioned -archives. +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. -The command command below imports metadata for the @code{fontspec} TeX -package: +La commande ci-dessous importe les métadonnées du paquet TeX @code{fontspec} +: @example guix import texlive fontspec @end example -When @code{--archive=DIRECTORY} is added, the source code is downloaded not -from the @file{latex} sub-directory of the @file{texmf-dist/source} tree in -the TeX Live SVN repository, but from the specified sibling directory under -the same root. +Lorsque l'option @code{--archive=DIRECTORY} est utilisée, le code source +n'est pas téléchargé depuis le sous-répertoire @file{latex} du +l'arborescence @file{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. -The command below imports metadata for the @code{ifxetex} package from CTAN -while fetching the sources from the directory @file{texmf/source/generic}: +La commande ci-dessous importe les métadonnées du paquet @code{ifxetex} +depuis CTAN en récupérant les sources depuis le répertoire +@file{texmf/source/generic} : @example guix import texlive --archive=generic ifxetex @@ -6597,9 +6795,10 @@ guix import texlive --archive=generic ifxetex @item json @cindex JSON, import -Import package metadata from a local JSON file@footnote{This functionality -requires Guile-JSON to be installed. @xref{Prérequis}.}. Consider the -following example package definition in JSON format: +Importe des métadonnées d'un fichier JSON local@footnote{Cette +fonctionnalité requiert l'installation de Guile-JSON. +@xref{Prérequis}.}. Considérez l'exemple suivant d'une définition de +paquet au format JSON : @example @{ @@ -6615,13 +6814,13 @@ following example package definition in JSON format: @} @end example -The field names are the same as for the @code{<package>} record -(@xref{Définition des paquets}). References to other packages are provided as -JSON lists of quoted package specification strings such as @code{guile} or -@code{guile@@2.0}. +Les noms des champs sont les mêmes que pour les enregistrements de +@code{<package>} (@xref{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 @code{guile} ou @code{guile@@2.0}. -The importer also supports a more explicit source definition using the -common fields for @code{<origin>} records: +L'importateur supporte aussi une définition plus explicite des sources avec +les champs habituels pour les enregistrements @code{<origin>} : @example @{ @@ -6637,37 +6836,39 @@ common fields for @code{<origin>} records: @} @end example -The command below reads metadata from the JSON file @code{hello.json} and -outputs a package expression: +La commande ci-dessous lit les métadonnées du fichier JSON @code{hello.json} +et renvoie une expression de paquet : @example guix import json hello.json @end example @item nix -Import metadata from a local copy of the source of the -@uref{http://nixos.org/nixpkgs/, Nixpkgs distribution}@footnote{This relies -on the @command{nix-instantiate} command of @uref{http://nixos.org/nix/, -Nix}.}. Package definitions in Nixpkgs are typically written in a mixture -of Nix-language and Bash code. This command only imports the high-level -package structure that is written in the Nix language. It normally includes -all the basic fields of a package definition. +Importe les métadonnées d'une copie locale des source de +@uref{http://nixos.org/nixpkgs/, la distribution Nixpkgs}@footnote{Cela +repose sur la commande @command{nix-instantiate} de +@uref{http://nixos.org/nix/, Nix}.}. 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. -When importing a GNU package, the synopsis and descriptions are replaced by -their canonical upstream variant. +Lorsque vous importez un paquet GNU, le synopsis et la description sont +replacés par la version canonique en amont. -Usually, you will first need to do: +Normalement, vous devrez d'abord faire : @example export NIX_REMOTE=daemon @end example @noindent -so that @command{nix-instantiate} does not try to open the Nix database. +pour que @command{nix-instantiate} n'essaye pas d'ouvrir la base de données +de Nix. -As an example, the command below imports the package definition of -LibreOffice (more precisely, it imports the definition of the package bound -to the @code{libreoffice} top-level attribute): +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 @code{libreoffice}) : @example guix import nix ~/path/to/nixpkgs libreoffice @@ -6675,42 +6876,48 @@ guix import nix ~/path/to/nixpkgs libreoffice @item hackage @cindex hackage -Import metadata from the Haskell community's central package archive -@uref{https://hackage.haskell.org/, Hackage}. Information is taken from -Cabal files and includes all the relevant information, including package -dependencies. +Importe les métadonnées de l'archive de paquets centrale de la communauté +Haskell, @uref{https://hackage.haskell.org/, Hackage}. Les informations +sont récupérées depuis les fichiers Cabal et incluent toutes les +informations utiles, dont les dépendances des paquets. -Specific command-line options are: +Les options spécifiques sont : @table @code @item --stdin @itemx -s -Read a Cabal file from standard input. +Lit un fichier Cabal depuis l'entrée standard. @item --no-test-dependencies @itemx -t -Do not include dependencies required only by the test suites. +N'inclut pas les dépendances requises uniquement par les suites de tests. @item --cabal-environment=@var{alist} @itemx -e @var{alist} -@var{alist} is a Scheme alist defining the environment in which the Cabal -conditionals are evaluated. The accepted keys are: @code{os}, @code{arch}, -@code{impl} and a string representing the name of a flag. The value -associated with a flag has to be either the symbol @code{true} or -@code{false}. The value associated with other keys has to conform to the -Cabal file format definition. The default value associated with the keys -@code{os}, @code{arch} and @code{impl} is @samp{linux}, @samp{x86_64} and -@samp{ghc}, respectively. +@var{alist} est une alist Scheme qui définie l'environnement dans lequel les +conditions de Cabal sont évaluées. Les clefs acceptées sont : @code{os}, +@code{arch}, @code{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 @code{true} ou @code{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 @code{os}, @code{arch} et +@code{impl} sont respectivement @samp{linux}, @samp{x86_64} et @samp{ghc}. +@item --recursive +@itemx -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. @end table -The command below imports metadata for the latest version of the @code{HTTP} -Haskell package without including test dependencies and specifying the value -of the flag @samp{network-uri} as @code{false}: +La commande ci-dessous importe les métadonnées de la dernière version du +paquet Haskell @code{HTTP} sans inclure les dépendances des tests et en +spécifiant la valeur du drapeau @samp{network-uri} comme étant @code{false} +: @example guix import hackage -t -e "'((\"network-uri\" . false))" HTTP @end example -A specific package version may optionally be specified by following the -package name by an at-sign and a version number as in the following example: +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 : @example guix import hackage mtl@@2.1.3.1 @@ -6718,26 +6925,27 @@ guix import hackage mtl@@2.1.3.1 @item stackage @cindex stackage -The @code{stackage} importer is a wrapper around the @code{hackage} one. It -takes a package name, looks up the package version included in a long-term -support (LTS) @uref{https://www.stackage.org, Stackage} release and uses the -@code{hackage} importer to retrieve its metadata. Note that it is up to you -to select an LTS release compatible with the GHC compiler used by Guix. +L'importateur @code{stackage} est une enveloppe autour de l'importateur +@code{hackage}. Il prend un nom de paquet, recherche la version incluse +dans une version au support étendu (LTS) de @uref{https://www.stackage.org, +Stackage} et utilise l'importateur @code{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. -Specific command-line options are: +Les options spécifiques sont : @table @code @item --no-test-dependencies @itemx -t -Do not include dependencies required only by the test suites. +N'inclut pas les dépendances requises uniquement par les suites de tests. @item --lts-version=@var{version} @itemx -r @var{version} -@var{version} is the desired LTS release version. If omitted the latest -release is used. +@var{version} est la version LTS désirée. Si elle est omise, la dernière +version est utilisée. @end table -The command below imports metadata for the @code{HTTP} Haskell package -included in the LTS Stackage release version 7.18: +La commande ci-dessous importe les métadonnées du paquet Haskell @code{HTTP} +inclus dans la version LTS 7.18 de Stackage : @example guix import stackage --lts-version=7.18 HTTP @@ -6745,89 +6953,96 @@ guix import stackage --lts-version=7.18 HTTP @item elpa @cindex elpa -Import metadata from an Emacs Lisp Package Archive (ELPA) package repository -(@pxref{Packages,,, emacs, The GNU Emacs Manual}). +Importe les métadonnées du dépôt de paquets ELPA (Emacs Lisp Package +Archive) (@pxref{Packages,,, emacs, The GNU Emacs Manual}). -Specific command-line options are: +Les options spécifiques sont : @table @code @item --archive=@var{repo} @itemx -a @var{repo} -@var{repo} identifies the archive repository from which to retrieve the -information. Currently the supported repositories and their identifiers -are: +@var{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 +: @itemize - @item -@uref{http://elpa.gnu.org/packages, GNU}, selected by the @code{gnu} -identifier. This is the default. +@uref{http://elpa.gnu.org/packages, GNU}, qu'on peut choisir avec +l'identifiant @code{gnu}. C'est la valeur par défaut. -Packages from @code{elpa.gnu.org} are signed with one of the keys contained -in the GnuPG keyring at @file{share/emacs/25.1/etc/package-keyring.gpg} (or -similar) in the @code{emacs} package (@pxref{Package Installation, ELPA +Les paquets de @code{elpa.gnu.org} avec l'une des clefs contenues dans le +porte-clef GnuPG @file{share/emacs/25.1/etc/package-keyring.gpg} (ou +similaire) dans le paquet @code{emacs} (@pxref{Package Installation, ELPA package signatures,, emacs, The GNU Emacs Manual}). @item -@uref{http://stable.melpa.org/packages, MELPA-Stable}, selected by the -@code{melpa-stable} identifier. +@uref{http://stable.melpa.org/packages, MELPA-Stable}, qu'on peut +sélectionner avec l'identifiant @code{melpa-stable}. @item -@uref{http://melpa.org/packages, MELPA}, selected by the @code{melpa} -identifier. +@uref{http://melpa.org/packages, MELPA}, qu'on peut sélectionner avec +l'identifiant @code{melpa}. @end itemize @item --recursive @itemx -r -Traverse the dependency graph of the given upstream package recursively and -generate package expressions for all those packages that are not yet in -Guix. +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. @end table @item crate @cindex crate -Import metadata from the crates.io Rust package repository +Importe les métadonnées du répertoire des paquets Rust @uref{https://crates.io, crates.io}. + +@item opam +@cindex OPAM +@cindex OCaml +Import metadata from the @uref{https://opam.ocaml.org/, OPAM} package +repository used by the OCaml community. @end table -The structure of the @command{guix import} code is modular. It would be -useful to have more importers for other package formats, and your help is -welcome here (@pxref{Contribuer}). +La structure du code de @command{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 (@pxref{Contribuer}). @node Invoquer guix refresh -@section Invoking @command{guix refresh} +@section Invoquer @command{guix refresh} @cindex @command{guix refresh} -The primary audience of the @command{guix refresh} command is developers of -the GNU software distribution. By default, it reports any packages provided -by the distribution that are outdated compared to the latest upstream -version, like this: +L'audience première de la commande @command{guix refresh} est l'ensemble des +développeurs de 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 : @example $ guix refresh -gnu/packages/gettext.scm:29:13: gettext would be upgraded from 0.18.1.1 to 0.18.2.1 -gnu/packages/glib.scm:77:12: glib would be upgraded from 2.34.3 to 2.37.0 +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 @end example -Alternately, one can specify packages to consider, in which case a warning -is emitted for packages that lack an updater: +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é : @example $ guix refresh coreutils guile guile-ssh -gnu/packages/ssh.scm:205:2: warning: no updater for guile-ssh -gnu/packages/guile.scm:136:12: guile would be upgraded from 2.0.12 to 2.0.13 +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 @end example -@command{guix refresh} browses the upstream repository of each package and -determines the highest version number of the releases therein. The command -knows how to update specific types of packages: GNU packages, ELPA packages, -etc.---see the documentation for @option{--type} below. There are many -packages, though, for which it lacks a method to determine whether a new -upstream release is available. However, the mechanism is extensible, so -feel free to get in touch with us to add a new method! +@command{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 @option{--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 ! -Sometimes the upstream name differs from the package name used in Guix, and -@command{guix refresh} needs a little help. Most updaters honor the -@code{upstream-name} property in package definitions, which can be used to -that effect: +Parfois les noms en amont diffèrent du nom de paquet utilisé par Guix et +@command{guix refresh} a besoin d'un peu d'aide. La plupart des +gestionnaires de mise à jour honorent la propriété @code{upstream-name} dans +les définitions de paquets, ce qui peut être utilisé à cette fin : @example (define-public network-manager @@ -6837,18 +7052,19 @@ that effect: (properties '((upstream-name . "NetworkManager"))))) @end example -When passed @code{--update}, it modifies distribution source files to update -the version numbers and source tarball hashes of those package recipes -(@pxref{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 @command{gpg}, and -finally computing its hash. 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, @command{guix refresh} reports an -error. +Lorsque l'option @code{--update} est utilisée, elle modifie les fichiers +source de la distribution pour mettre à jour le numéro de version et le hash +de l'archive source de ces recettes de paquets (@pxref{Définition des paquets}). +Cela est effectué en téléchargeant la dernière version de l'archive des +sources de chaque paquet et des signatures associées, en authentifiant +l'archive téléchargée avec sa signature en utilisant @command{gpg} puis en +calculant son hash. Lorsque la clef publique utilisée pour signer l'archive +manque du porte-clefs de l'utilisateur, le gestionnaire tente de la +récupérer automatiquement d'un serveur de clef public ; si cela réussi, la +clef est ajoutée au porte-clefs de l'utilisateur, sinon @command{guix +refresh} rapporte une erreur. -The following options are supported: +Les options suivantes sont supportées : @table @code @@ -6856,136 +7072,155 @@ The following options are supported: @itemx -e @var{expr} Considérer le paquet évalué par @var{expr}. -This is useful to precisely refer to a package, as in this example: +C'est utile pour précisément se référer à un paquet, comme dans cet exemple +: @example guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)' @end example -This command lists the dependents of the ``final'' libc (essentially all the -packages.) +Cette commande liste les paquets qui dépendent de la libc « finale » (en +gros tous les paquets). @item --update @itemx -u -Update distribution source files (package recipes) in place. This is -usually run from a checkout of the Guix source tree (@pxref{Lancer Guix avant qu'il ne soit installé}): +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 (@pxref{Lancer Guix avant qu'il ne soit installé}) : @example $ ./pre-inst-env guix refresh -s non-core -u @end example -@xref{Définition des paquets}, for more information on package definitions. +@xref{Définition des paquets}, pour plus d'information sur les définitions des +paquets. @item --select=[@var{subset}] @itemx -s @var{subset} -Select all the packages in @var{subset}, one of @code{core} or +Choisi tous les paquets dans @var{subset}, entre @code{core} et @code{non-core}. -The @code{core} subset refers to all the packages at the core of the -distribution---i.e., packages that are used to build ``everything else''. -This includes GCC, libc, Binutils, Bash, etc. Usually, changing one of -these packages in the distribution entails a rebuild of all the others. -Thus, such updates are an inconvenience to users in terms of build time or -bandwidth used to achieve the upgrade. +Le sous-ensemble @code{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 rest ». 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. -The @code{non-core} subset refers to the remaining packages. It is -typically useful in cases where an update of the core packages would be -inconvenient. +Le sous-ensemble @code{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. @item --manifest=@var{fichier} @itemx -m @var{fichier} -Select all the packages from the manifest in @var{file}. This is useful to -check if any packages of the user manifest can be updated. +Choisi tous les paquets du manifeste dans @var{file}. C'est utile pour +vérifier qu'aucun des paquets du manifeste utilisateur ne peut être mis à +jour. @item --type=@var{updater} @itemx -t @var{updater} -Select only packages handled by @var{updater} (may be a comma-separated list -of updaters). Currently, @var{updater} may be one of: +Chois uniquement les paquets pris en charge par @var{updater} +(éventuellement une liste de gestionnaires de mise à jour séparés par des +virgules). Actuellement, @var{updater} peut être l'une des valeurs suivantes +: @table @code @item gnu -the updater for GNU packages; +le gestionnaire de mise à jour pour les paquets GNU ; @item gnome -the updater for GNOME packages; +le gestionnaire de mise à jour pour les paquets GNOME ; @item kde -the updater for KDE packages; +le gestionnaire de mise à jour pour les paquets KDE ; @item xorg -the updater for X.org packages; +le gestionnaire de mise à jour pour les paquets X.org ; @item kernel.org -the updater for packages hosted on kernel.org; +le gestionnaire de mise à jour pour les paquets hébergés sur kernel.org ; @item elpa -the updater for @uref{http://elpa.gnu.org/, ELPA} packages; +le gestionnaire de mise à jour pour les paquets @uref{http://elpa.gnu.org/, +ELPA} ; @item cran -the updater for @uref{https://cran.r-project.org/, CRAN} packages; +le gestionnaire de mise à jour pour les paquets +@uref{https://cran.r-project.org/, CRAN} ; @item bioconductor -the updater for @uref{https://www.bioconductor.org/, Bioconductor} R -packages; +le gestionnaire de mise à jour pour les paquets +@uref{https://www.bioconductor.org/, Bioconductor} ; @item cpan -the updater for @uref{http://www.cpan.org/, CPAN} packages; +le gestionnaire de mise à jour pour les paquets @uref{http://www.cpan.org/, +CPAN} ; @item pypi -the updater for @uref{https://pypi.python.org, PyPI} packages. +le gestionnaire de mise à jour pour les paquets +@uref{https://pypi.python.org, PyPI} ; @item gem -the updater for @uref{https://rubygems.org, RubyGems} packages. +le gestionnaire de mise à jour pour les paquets @uref{https://rubygems.org, +RubyGems} ; @item github -the updater for @uref{https://github.com, GitHub} packages. +le gestionnaire de mise à jour pour les paquets @uref{https://github.com, +GitHub} ; @item hackage -the updater for @uref{https://hackage.haskell.org, Hackage} packages. +le gestionnaire de mise à jour pour les paquets +@uref{https://hackage.haskell.org, Hackage} ; @item stackage -the updater for @uref{https://www.stackage.org, Stackage} packages. +le gestionnaire de mise à jour pour les paquets +@uref{https://www.stackage.org, Stackage} ; @item crate -the updater for @uref{https://crates.io, Crates} packages. +le gestionnaire de mise à jour pour les paquets @uref{https://crates.io, +Crates} ; @end table -For instance, the following command only checks for updates of Emacs -packages hosted at @code{elpa.gnu.org} and for updates of CRAN packages: +Par exemple, la commande suivante ne vérifie que les mises à jour des +paquets Emacs hébergés sur @code{elpa.gnu.org} et les paquets CRAN : @example $ guix refresh --type=elpa,cran -gnu/packages/statistics.scm:819:13: r-testthat would be upgraded from 0.10.0 to 0.11.0 -gnu/packages/emacs.scm:856:13: emacs-auctex would be upgraded from 11.88.6 to 11.88.9 +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 @end example @end table -In addition, @command{guix refresh} can be passed one or more package names, -as in this example: +En plus, on peut passer à @command{guix refresh} un ou plusieurs noms de +paquets, comme dans cet exemple : @example $ ./pre-inst-env guix refresh -u emacs idutils gcc@@4.8 @end example @noindent -The command above specifically updates the @code{emacs} and @code{idutils} -packages. The @code{--select} option would have no effect in this case. +La commande au-dessus met à jour spécifiquement les paquets @code{emacs} et +@code{idutils}. L'option @code{--select} n'aurait aucun effet dans ce cas. -When considering whether to upgrade a package, it is sometimes convenient to -know which packages would be affected by the upgrade and should be checked -for compatibility. For this the following option may be used when passing -@command{guix refresh} one or more package names: +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 à @command{guix refresh} : @table @code @item --list-updaters @itemx -L -List available updaters and exit (see @option{--type} above.) +Liste les gestionnaires de mise à jour et quitte (voir l'option +@option{--type} plus haut). -For each updater, display the fraction of packages it covers; at the end, -display the fraction of packages covered by all these updaters. +Pour chaque gestionnaire, affiche le pourcentage de paquets qu'il couvre ; à +la fin, affiche le pourcentage de paquets couverts par tous les +gestionnaires. @item --list-dependent @itemx -l -List top-level dependent packages that would need to be rebuilt as a result -of upgrading one or more packages. +Liste les paquets de plus haut-niveau qui devraient être reconstruits après +la mise à jour d'un ou plusieurs paquets. -@xref{Invoquer guix graph, the @code{reverse-package} type of @command{guix -graph}}, for information on how to visualize the list of dependents of a -package. +@xref{Invoquer guix graph, le type @code{reverse-package} de @command{guix +graph}}, pour des informations sur la manière de visualiser la liste des +paquets dépendant d'un autre. @end table -Be aware that the @code{--list-dependent} option only @emph{approximates} -the rebuilds that would be required as a result of an upgrade. More -rebuilds might be required under some circumstances. +Soyez conscients que l'option @code{--list-dependent} ne fait +@emph{qu'approximer} les reconstructions qui seraient requises par une mise +à jour. Plus de reconstructions pourraient être requises dans certaines +circonstances. @example $ guix refresh --list-dependent flex @@ -6993,102 +7228,114 @@ Building the following 120 packages would ensure 213 dependent packages are rebu hop@@2.4.0 geiser@@0.4 notmuch@@0.18 mu@@0.9.9.5 cflow@@1.4 idutils@@4.6 @dots{} @end example -The command above lists a set of packages that could be built to check for -compatibility with an upgraded @code{flex} package. +La commande ci-dessus liste un ensemble de paquets qui peuvent être +construits pour vérifier la compatibilité d'une mise à jour de @code{flex}. -The following options can be used to customize GnuPG operation: +Les options suivante peuvent être utilisées pour personnaliser les +opérations avec GnuPG : @table @code -@item --gpg=@var{command} -Use @var{command} as the GnuPG 2.x command. @var{command} is searched for -in @code{$PATH}. +@item --gpg=@var{commande} +Utilise @var{commande} comme la commande de GnuPG 2.x. @var{commande} est +recherchée dans @code{PATH}. -@item --key-download=@var{policy} -Handle missing OpenPGP keys according to @var{policy}, which may be one of: +@item --key-download=@var{politique} +Gère les clefs OpenPGP manquantes d'après la @var{politique}, qui peut être +l'une des suivantes : @table @code @item always -Always download missing OpenPGP keys from the key server, and add them to -the user's GnuPG keyring. +Toujours télécharger les clefs manquantes depuis un serveur de clefs et les +ajouter au porte-clefs de l'utilisateur. @item never -Never try to download missing OpenPGP keys. Instead just bail out. +Ne jamais essayer de télécharger les clefs OpenPGP manquante. Quitter à la +place. @item interactive -When a package signed with an unknown OpenPGP key is encountered, ask the -user whether to download it or not. This is the default behavior. +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. @end table @item --key-server=@var{host} -Use @var{host} as the OpenPGP key server when importing a public key. +Utiliser @var{host} comme serveur de clefs OpenPGP lors de l'importe d'une +clef publique. @end table -The @code{github} updater uses the @uref{https://developer.github.com/v3/, -GitHub API} to query for new releases. When used repeatedly e.g. when -refreshing all packages, GitHub will eventually refuse to answer any further -API requests. By default 60 API requests per hour are allowed, and a full -refresh on all GitHub packages in Guix requires more than this. -Authentication with GitHub through the use of an API token alleviates these -limits. To use an API token, set the environment variable -@code{GUIX_GITHUB_TOKEN} to a token procured from -@uref{https://github.com/settings/tokens} or otherwise. +Le gestionnaire de mises à jour @code{github} utilise +@uref{https://developer.github.com/v3/, 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 +@code{GUIX_GITHUB_TOKEN} avec un jeton que vous vous serez procuré sur +@uref{https://github.com/settings/tokens} ou autrement. @node Invoquer guix lint -@section Invoking @command{guix lint} +@section Invoquer @command{guix lint} @cindex @command{guix lint} -@cindex package, checking for errors -The @command{guix lint} command is meant to help package developers avoid -common errors and use a consistent style. It runs a number of checks on a -given set of packages in order to find common mistakes in their -definitions. Available @dfn{checkers} include (see @code{--list-checkers} -for a complete list): +@cindex paquets, chercher des erreurs +La commande @command{guix lint} est conçue pour aider les développeurs à +éviter des erreurs commune 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 @dfn{vérifieurs} disponibles comprennent (voir +@code{--list-checkers} pour une liste complète) : @table @code @item synopsis @itemx description -Validate certain typographical and stylistic rules about package -descriptions and synopses. +Vérifie certaines règles typographiques et stylistiques dans les +descriptions et les synopsis. @item inputs-should-be-native -Identify inputs that should most likely be native inputs. +Identifie les entrées qui devraient sans doute plutôt être des entrées +natives. @item source @itemx home-page @itemx mirror-url @itemx source-file-name -Probe @code{home-page} and @code{source} URLs and report those that are -invalid. Suggest a @code{mirror://} URL when applicable. Check that the -source file name is meaningful, e.g. is not just a version number or -``git-checkout'', without a declared @code{file-name} (@pxref{Référence d'origine}). +Sonde les URL @code{home-page} et @code{source} et rapporte celles qui sont +invalides. Suggère une URL en @code{mirror://} lorsque c'est possible. +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-checkou », sans avoir déclaré un +@code{file-name} (@pxref{Référence d'origine}). @item cve -@cindex security vulnerabilities +@cindex vulnérabilités @cindex CVE, Common Vulnerabilities and Exposures -Report known vulnerabilities found in the Common Vulnerabilities and -Exposures (CVE) databases of the current and past year -@uref{https://nvd.nist.gov/download.cfm#CVE_FEED, published by the US NIST}. +Rapporte les vulnérabilités connues trouvées dans les bases de données CVE +(Common Vulnerabilities and Exposures) de l'année en cours et des années +précédentes @uref{https://nvd.nist.gov/download.cfm#CVE_FEED, publié par le +NIST américain}. -To view information about a particular vulnerability, visit pages such as: +Pour voir les informations sur une vulnérabilité en particulier, visitez les +pages : @itemize @item -@indicateurl{https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-YYYY-ABCD} +@indicateurl{https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-ANNÉE-ABCD} @item -@indicateurl{https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-YYYY-ABCD} +@indicateurl{https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-ANNÉE-ABCD} @end itemize @noindent -where @code{CVE-YYYY-ABCD} is the CVE identifier---e.g., +où @code{CVE-ANNÉE-ABCD} est l'identifiant CVE — p.@: ex.@: @code{CVE-2015-7554}. -Package developers can specify in package recipes the -@uref{https://nvd.nist.gov/cpe.cfm,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: +Les développeurs de paquets peuvent spécifier dans les recettes des paquets +le nom @uref{https://nvd.nist.gov/cpe.cfm,CPE (Common Platform Enumeration)} +et la version du paquet s'ils diffèrent du nom et de la version que Guix +utilise, comme dans cet exemple : @example (package @@ -7100,16 +7347,16 @@ Guix uses, as in this example: @end example @c See <http://www.openwall.com/lists/oss-security/2017/03/15/3>. -Some entries in the CVE database do not specify which version of a package -they apply to, and would thus ``stick around'' forever. Package developers -who found CVE alerts and verified they can be ignored can declare them as in -this example: +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éveloppeurs qui trouvent des alertes CVE et ont vérifiés +qu'elles peuvent être ignorées peuvent les déclarer comme dans cet exemple : @example (package (name "t1lib") ;; @dots{} - ;; These CVEs no longer apply and can be safely ignored. + ;; 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" @@ -7117,8 +7364,8 @@ this example: @end example @item formatting -Warn about obvious source code formatting issues: trailing white space, use -of tabulations, etc. +Avertit le développeurs lorsqu'il y a des problèmes de formatage du code +source évident : des espaces en fin de ligne, des tabulations, etc. @end table La syntaxe générale est : @@ -7127,38 +7374,40 @@ La syntaxe générale est : guix lint @var{options} @var{package}@dots{} @end example -If no package is given on the command line, then all packages are checked. -The @var{options} may be zero or more of the following: +Si aucun paquet n'est donné par la ligne de commande, tous les paquets +seront vérifiés. Les @var{options} peuvent contenir aucune ou plus des +options suivantes : @table @code @item --list-checkers @itemx -l -List and describe all the available checkers that will be run on packages -and exit. +Liste et décrit tous les vérificateurs disponibles qui seront lancés sur les +paquets puis quitte. @item --checkers @itemx -c -Only enable the checkers specified in a comma-separated list using the names -returned by @code{--list-checkers}. +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 @code{--list-checkers}. @end table @node Invoquer guix size -@section Invoking @command{guix size} +@section Invoquer @command{guix size} -@cindex size -@cindex package size +@cindex taille +@cindex paquet, taille @cindex closure @cindex @command{guix size} -The @command{guix size} command helps package developers profile the disk -usage of packages. It is easy to overlook the impact of an additional -dependency added to a package, or the impact of using a single output for a -package that could easily be split (@pxref{Des paquets avec plusieurs résultats}). Such are the typical issues that @command{guix size} can -highlight. +La commande @command{guix size} aide les développeurs à dresser un profil de +l'utilisation du disque que font les paquets. C'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é (@pxref{Des paquets avec plusieurs résultats}). Ce sont les +problèmes que @command{guix size} peut typiquement mettre en valeur. -The command can be passed one or more package specifications such as -@code{gcc@@4.8} or @code{guile:debug}, or a file name in the store. -Consider this example: +On peut passer un ou plusieurs spécifications de paquets à la commande, +comme @code{gcc@@4.8} ou @code{guile:debug}, ou un nom de fichier dans le +dépôt. Regardez cet exemple : @example $ guix size coreutils @@ -7175,34 +7424,36 @@ total: 78.9 MiB @end example @cindex closure -The store items listed here constitute the @dfn{transitive closure} of -Coreutils---i.e., Coreutils and all its dependencies, recursively---as would -be returned by: +Les éléments du dépôt listés ici constituent la @dfn{cloture transitive} de +Coreutils — c.-à-d.@: Coreutils et toutes ses dépendances, récursivement — +comme ce qui serait renvoyé par : @example $ guix gc -R /gnu/store/@dots{}-coreutils-8.23 @end example -Here the output shows three columns next to store items. The first column, -labeled ``total'', shows the size in mebibytes (MiB) of the closure of the -store item---that is, its own size plus the size of all its dependencies. -The next column, labeled ``self'', shows the size of the item itself. The -last column shows the ratio of the size of the item itself to the space -occupied by all the items listed here. - -In this example, we see that the closure of Coreutils weighs in at -79@tie{}MiB, most of which is taken by libc and GCC's run-time support -libraries. (That libc and GCC's libraries represent a large fraction of the -closure is not a problem @i{per se} because they are always available on the -system anyway.) - -When the package(s) passed to @command{guix size} are available in the -store@footnote{More precisely, @command{guix size} looks for the -@emph{ungrafted} variant of the given package(s), as returned by @code{guix -build @var{package} --no-grafts}. @xref{Mises à jour de sécurité}, for information -on grafts.}, @command{guix size} queries the daemon to determine its -dependencies, and measures its size in the store, similar to @command{du -ms ---apparent-size} (@pxref{du invocation,,, coreutils, GNU Coreutils}). +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 cloture 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 cloture de Coreutils pèse 79@tie{}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 cloture parce qu'elles sont toujours +disponibles sur le système de toute façon). + +Lorsque les paquets passés à @command{guix size} sont disponibles dans le +dépôt@footnote{Plus précisément, @command{guix size} cherche les variantes +@emph{non greffées} des paquets donnés, tels qu'ils sont renvoyés par +@code{guix build @var{paquet} --no-graft}. @xref{Mises à jour de sécurité} pour des +informations sur les greffes}, @command{guix size} demande au démon de +déterminer ses dépendances, et mesure sa taille dans le dépôt, comme avec +@command{du -ms --apparent-size} (@pxref{du invocation,,, coreutils, GNU +Coreutils}). Lorsque les paquets donnés ne sont @emph{pas} dans le dépôt, @command{guix size} rapporte les informations en se basant sur les substituts disponibles @@ -7210,7 +7461,7 @@ size} rapporte les informations en se basant sur les substituts disponibles éléments du dépôt même s'ils ne sont pas sur le disque, mais disponibles à distance. -You can also specify several package names: +Vous pouvez aussi spécifier plusieurs noms de paquets : @example $ guix size coreutils grep sed bash @@ -7224,218 +7475,225 @@ total: 102.3 MiB @end example @noindent -In this example we see that the combination of the four packages takes -102.3@tie{}MiB in total, which is much less than the sum of each closure -since they have a lot of dependencies in common. +Dans cet exemple on voit que la combinaison des quatre paquets prent +102.3@tie{}Mio en tout, ce qui est bien moins que la somme des clotures +puisqu'ils ont beaucoup de dépendances en commun. -The available options are: +Les options disponibles sont : @table @option @item --substitute-urls=@var{urls} -Use substitute information from @var{urls}. @xref{client-substitute-urls, -the same option for @code{guix build}}. +Utilise les informations de substituts de @var{urls}. +@xref{client-substitute-urls, the same option for @code{guix build}}. -@item --sort=@var{key} -Sort lines according to @var{key}, one of the following options: +@item --sort=@var{clef} +Trie les lignes en fonction de la @var{clef}, l'une des optinos suivantes : @table @code @item self -the size of each item (the default); +la taille de chaque élément (par défaut) ; @item closure -the total size of the item's closure. +la taille totale de la cloture de l'élémente. @end table -@item --map-file=@var{file} -Write a graphical map of disk usage in PNG format to @var{file}. +@item --map-file=@var{fichier} +Écrit un schéma de l'utilisation du disque au format PNG dans @var{fichier}. -For the example above, the map looks like this: +Pour l'exemple au-dessus, le schéma ressemble à ceci : -@image{images/coreutils-size-map,5in,, map of Coreutils disk usage produced -by @command{guix size}} +@image{images/coreutils-size-map,5in,, schéma de l'utilisation du disque de +Coreutils produit par @command{guix size}} -This option requires that -@uref{http://wingolog.org/software/guile-charting/, Guile-Charting} be -installed and visible in Guile's module search path. When that is not the -case, @command{guix size} fails as it tries to load it. +Cette option requiert l'installation de +@uref{http://wingolog.org/software/guile-charting/, Guile-Charting} et qu'il +soit visible dans le chemin de recherche des modules Guile. Lorsque ce +n'est pas le cas, @command{guix size} plante en essayant de le charger. @item --system=@var{système} @itemx -s @var{système} -Consider packages for @var{system}---e.g., @code{x86_64-linux}. +Considère les paquets pour @var{système} — p.@: ex.@: @code{x86_64-linux}. @end table @node Invoquer guix graph -@section Invoking @command{guix graph} +@section Invoque @command{guix graph} @cindex DAG @cindex @command{guix graph} @cindex dépendances des paquets -Packages and their dependencies form a @dfn{graph}, specifically a directed -acyclic graph (DAG). It can quickly become difficult to have a mental model -of the package DAG, so the @command{guix graph} command provides a visual -representation of the DAG. By default, @command{guix graph} emits a DAG -representation in the input format of @uref{http://www.graphviz.org/, -Graphviz}, so its output can be passed directly to the @command{dot} command -of Graphviz. It can also emit an HTML page with embedded JavaScript code to -display a ``chord diagram'' in a Web browser, using the -@uref{https://d3js.org/, d3.js} library, or emit Cypher queries to construct -a graph in a graph database supporting the @uref{http://www.opencypher.org/, -openCypher} query language. The general syntax is: +Les paquets et leurs dépendances forment un @dfn{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 +@command{guix graph} fournit une représentation visuelle du DAG. Par +défaut, @command{guix graph} émet un représentation du DAG dans le format +d'entrée de @uref{http://www.graphviz.org/, Graphviz}, pour que sa sortie +puisse être passée directement à la commande @command{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 +@uref{https://d3js.org/, 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 @uref{http://www.opencypher.org/, openCypher}. La +syntaxe générale est : @example -guix graph @var{options} @var{package}@dots{} +guix graph @var{options} @var{paquet}@dots{} @end example -For example, the following command generates a PDF file representing the -package DAG for the GNU@tie{}Core Utilities, showing its build-time -dependencies: +Par exemple, la commande suivante génère un fichier PDF représentant le DAG +du paquet pour GNU@tie{}Core Utilities, qui montre ses dépendances à la +compilation : @example guix graph coreutils | dot -Tpdf > dag.pdf @end example -The output looks like this: +La sortie ressemble à ceci : -@image{images/coreutils-graph,2in,,Dependency graph of the GNU Coreutils} +@image{images/coreutils-graph,2in,,Graphe de dépendance de GNU Coreutils} -Nice little graph, no? +Joli petit graphe, non ? -But there is more than one graph! The one above is concise: it is the graph -of package objects, omitting implicit inputs such as GCC, libc, grep, etc. -It is often useful to have such a concise graph, but sometimes one may want -to see more details. @command{guix graph} supports several types of graphs, -allowing you to choose the level of detail: +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. @command{guix graph} supporte +plusieurs types de graphes, qui vous permettent de choisir le niveau de +détails : @table @code @item package -This is the default type used in the example above. It shows the DAG of -package objects, excluding implicit dependencies. It is concise, but -filters out many details. +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. @item reverse-package -This shows the @emph{reverse} DAG of packages. For example: +Cela montre le DAG @emph{inversé} des paquets. Par exemple : @example guix graph --type=reverse-package ocaml @end example -... yields the graph of packages that depend on OCaml. +… montre le graphe des paquets qui dépendent de OCaml. -Note that for core packages this can yield huge graphs. If all you want is -to know the number of packages that depend on a given package, use -@command{guix refresh --list-dependent} (@pxref{Invoquer guix refresh, +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 @command{guix refresh +--list-dependent} (@pxref{Invoquer guix refresh, @option{--list-dependent}}). @item bag-emerged -This is the package DAG, @emph{including} implicit inputs. +C'est le DAG du paquet, @emph{avec} les entrées implicites. -For instance, the following command: +Par exemple, la commande suivante : @example guix graph --type=bag-emerged coreutils | dot -Tpdf > dag.pdf @end example -... yields this bigger graph: +… montre ce graphe plus gros : -@image{images/coreutils-bag-graph,,5in,Detailed dependency graph of the GNU -Coreutils} +@image{images/coreutils-bag-graph,,5in,Graphe des dépendances détaillé de +GNU Coreutils} -At the bottom of the graph, we see all the implicit inputs of +En bas du graphe, on voit toutes les entrées implicites de @var{gnu-build-system} (@pxref{Systèmes de construction, @code{gnu-build-system}}). -Now, note that the dependencies of these implicit inputs---that is, the -@dfn{bootstrap dependencies} (@pxref{Bootstrapping})---are not shown here, -for conciseness. +Maintenant, remarquez que les dépendances de ces entrées implicites — +c'est-à-dire les @dfn{dépendances de bootstrap} (@pxref{Bootstrapping}) — ne +sont pas affichées, pour rester concis. @item bag -Similar to @code{bag-emerged}, but this time including all the bootstrap -dependencies. +Comme @code{bag-emerged} mais cette fois inclus toutes les dépendances de +bootstrap. @item bag-with-origins -Similar to @code{bag}, but also showing origins and their dependencies. +Comme @code{bag}, mais montre aussi les origines et leurs dépendances. @item dérivation -This is the most detailed representation: It shows the DAG of derivations -(@pxref{Dérivations}) and plain store items. Compared to the above -representation, many additional nodes are visible, including build scripts, -patches, Guile modules, etc. +C'est la représentation lu plus détaillée : elle montre le DAG des +dérivations (@pxref{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. -For this type of graph, it is also possible to pass a @file{.drv} file name -instead of a package name, as in: +Pour ce type de graphe, il est aussi possible de passer un nom de fichier +@file{.drv} à la place d'un nom de paquet, comme dans : @example guix graph -t derivation `guix system build -d my-config.scm` @end example @item module -This is the graph of @dfn{package modules} (@pxref{Modules de paquets}). For -example, the following command shows the graph for the package module that -defines the @code{guile} package: +C'est le graphe des @dfn{modules de paquets} (@pxref{Modules de paquets}). Par +exemple, la commande suivante montre le graphe des modules de paquets qui +définissent le paquet @code{guile} : @example guix graph -t module guile | dot -Tpdf > module-graph.pdf @end example @end table -All the types above correspond to @emph{build-time dependencies}. The -following graph type represents the @emph{run-time dependencies}: +Tous les types ci-dessus correspondent aux @emph{dépendances à la +construction}. Le type de graphe suivant représente les @emph{dépendances à +l'exécution} : @table @code @item references -This is the graph of @dfn{references} of a package output, as returned by -@command{guix gc --references} (@pxref{Invoquer guix gc}). +C'est le graphe des @dfn{references} d'une sortie d'un paquet, telles que +renvoyées par @command{guix gc --references} (@pxref{Invoquer guix gc}). -If the given package output is not available in the store, @command{guix -graph} attempts to obtain dependency information from substitutes. +Si la sortie du paquet donnée n'est pas disponible dans le dépôt, +@command{guix graph} essayera d'obtenir les informations sur les dépendances +à travers les substituts. -Here you can also pass a store file name instead of a package name. For -example, the command below produces the reference graph of your profile -(which can be big!): +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 !) : @example guix graph -t references `readlink -f ~/.guix-profile` @end example @item referrers -This is the graph of the @dfn{referrers} of a store item, as returned by -@command{guix gc --referrers} (@pxref{Invoquer guix gc}). +C'est le graphe des @dfn{référents} d'un élément du dépôt, tels que renvoyés +par @command{guix gc --referrers} (@pxref{Invoquer guix gc}). -This relies exclusively on local information from your store. For instance, -let us suppose that the current Inkscape is available in 10 profiles on your -machine; @command{guix graph -t referrers inkscape} will show a graph rooted -at Inkscape and with those 10 profiles linked to it. +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 ; @command{guix graph -t referrers inkscape} montrera le graphe dont +la racine est Inkscape avec 10 profils qui y sont liés. -It can help determine what is preventing a store item from being garbage -collected. +Cela peut aider à déterminer ce qui empêche un élément du dépôt d'être +glané. @end table -The available options are the following: +Les options disponibles sont les suivante : @table @option @item --type=@var{type} @itemx -t @var{type} -Produce a graph output of @var{type}, where @var{type} must be one of the -values listed above. +Produit un graphe en sortie de type @var{type} où @var{type} doit être l'un +des types au-dessus. @item --list-types -List the supported graph types. +Liste les types de graphes supportés. -@item --backend=@var{backend} -@itemx -b @var{backend} -Produce a graph using the selected @var{backend}. +@item --backend=@var{moteur} +@itemx -b @var{moteur} +Produit un graphe avec le @var{moteur} choisi. @item --list-backends -List the supported graph backends. +Liste les moteurs de graphes supportés. -Currently, the available backends are Graphviz and d3.js. +Actuellement les moteurs disponibles sont Graphviz et d3.js. @item --expression=@var{expr} @itemx -e @var{expr} Considérer le paquet évalué par @var{expr}. -This is useful to precisely refer to a package, as in this example: +C'est utile pour précisément se référer à un paquet, comme dans cet exemple +: @example guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)' @@ -7444,51 +7702,54 @@ guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)' @node Invoquer guix environment -@section Invoking @command{guix environment} +@section Invoquer @command{guix environment} -@cindex reproducible build environments -@cindex development environments +@cindex environnements de construction reproductibles +@cindex environnement de développement @cindex @command{guix environment} -@cindex environment, package build environment -The purpose of @command{guix environment} is to assist hackers in creating -reproducible development environments without polluting their package -profile. The @command{guix environment} tool takes one or more packages, -builds all of their inputs, and creates a shell environment to use them. +@cindex environnement de construction de paquets +Le but de @command{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 @command{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 : @example -guix environment @var{options} @var{package}@dots{} +guix environment @var{options} @var{paquet}@dots{} @end example -The following example spawns a new shell set up for the development of -GNU@tie{}Guile: +L'exemple suivant crée un nouveau shell préparé pour le développement de +GNU@tie{}Guile : @example guix environment guile @end example -If the needed dependencies are not built yet, @command{guix environment} -automatically builds them. The environment of the new shell is an augmented -version of the environment that @command{guix environment} was run in. It -contains the necessary search paths for building the given package added to -the existing environment variables. To create a ``pure'' environment, in -which the original environment variables have been unset, use the -@code{--pure} option@footnote{Users sometimes wrongfully augment environment -variables such as @code{PATH} in their @file{~/.bashrc} file. As a -consequence, when @code{guix environment} launches it, Bash may read -@file{~/.bashrc}, thereby introducing ``impurities'' in these environment -variables. It is an error to define such environment variables in -@file{.bashrc}; instead, they should be defined in @file{.bash_profile}, -which is sourced only by log-in shells. @xref{Bash Startup Files,,, bash, -The GNU Bash Reference Manual}, for details on Bash start-up files.}. +Si les dépendances requises ne sont pas déjà construites, @command{guix +environment} les construit automatiquement. L'environnement du nouveau +shell est une version améliorée de l'environnement dans lequel @command{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 +@code{--pure}@footnote{Les utilisateurs ajoutent parfois à tord des valeurs +supplémentaires dans les variables comme @code{PATH} dans leur +@file{~/.bashrc}. En conséquence, lorsque @code{guix environment} le lance, +Bash peut lire @file{~/.bashrc}, ce qui produit des « impuretés » dans ces +variables d'environnement. C'est une erreur de définir ces variables +d'environnement dans @file{.bashrc} ; à la place, elles devraient être +définie dans @file{.bash_profile}, qui est sourcé uniquement par les shells +de connexion. @xref{Bash Startup Files,,, bash, The GNU Bash Reference +Manual}, pour des détails sur les fichiers de démarrage de Bash.}. @vindex GUIX_ENVIRONMENT -@command{guix environment} defines the @code{GUIX_ENVIRONMENT} variable in -the shell it spawns; its value is the file name of the profile of this -environment. This allows users to, say, define a specific prompt for -development environments in their @file{.bashrc} (@pxref{Bash Startup -Files,,, bash, The GNU Bash Reference Manual}): +@command{guix environment} définie la variable @code{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 @file{.bashrc} +(@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}) : @example if [ -n "$GUIX_ENVIRONMENT" ] @@ -7498,119 +7759,119 @@ fi @end example @noindent -... or to browse the profile: +… ou de naviguer dans le profil : @example $ ls "$GUIX_ENVIRONMENT/bin" @end example -Additionally, more than one package may be specified, in which case the -union of the inputs for the given packages are used. For example, the -command below spawns a shell where all of the dependencies of both Guile and -Emacs are available: +En plus, 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 : @example guix environment guile emacs @end example -Sometimes an interactive shell session is not desired. An arbitrary command -may be invoked by placing the @code{--} token to separate the command from -the rest of the arguments: +Parfois, une session shell interactive est inutile. On peut invoquer une +commande arbitraire en plaçant le jeton @code{--} pour séparer la commande +du reste des arguments : @example guix environment guile -- make -j4 @end example -In other situations, it is more convenient to specify the list of packages -needed in the environment. For example, the following command runs -@command{python} from an environment containing Python@tie{}2.7 and NumPy: +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 @command{python} dans un environnement contenant Python@tie{}2.7 et +NumPy : @example guix environment --ad-hoc python2-numpy python-2.7 -- python @end example -Furthermore, one might want the dependencies of a package and also some -additional packages that are not build-time or runtime dependencies, but are -useful when developing nonetheless. Because of this, the @code{--ad-hoc} -flag is positional. Packages appearing before @code{--ad-hoc} are -interpreted as packages whose dependencies will be added to the -environment. Packages appearing after are interpreted as packages that will -be added to the environment directly. For example, the following command -creates a Guix development environment that additionally includes Git and -strace: +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 @code{--ad-hoc} est positionnel. Les paquets qui +apparaissent avant @code{--ad-hoc} sont interprétés comme les paquets dont +les dépendances seront ajoutées à l'environnement. Les paquets qui +apparaissent après @code{--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 : @example guix environment guix --ad-hoc git strace @end example -Sometimes it is desirable to isolate the environment as much as possible, -for maximal purity and reproducibility. In particular, when using Guix on a -host distro that is not GuixSD, it is desirable to prevent access to -@file{/usr/bin} and other system-wide resources from the development -environment. For example, the following command spawns a Guile REPL in a -``container'' where only the store and the current working directory are -mounted: +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 GuixSD, il est +souhaitable d'éviter l'accès à @file{/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 : @example guix environment --ad-hoc --container guile -- guile @end example @quotation Remarque -The @code{--container} option requires Linux-libre 3.19 or newer. +L'option @code{--container} requiert Linux-libre 3.19 ou supérieur. @end quotation -The available options are summarized below. +Les options disponibles sont résumées ci-dessous. @table @code -@item --root=@var{file} -@itemx -r @var{file} -@cindex persistent environment -@cindex garbage collector root, for environments -Make @var{file} a symlink to the profile for this environment, and register -it as a garbage collector root. - -This is useful if you want to protect your environment from garbage -collection, to make it ``persistent''. - -When this option is omitted, the environment is protected from garbage -collection only for the duration of the @command{guix environment} session. -This means that next time you recreate the same environment, you could have -to rebuild or re-download packages. @xref{Invoquer guix gc}, for more on GC -roots. +@item --root=@var{fichier} +@itemx -r @var{fichier} +@cindex environnement persistent +@cindex racine du ramasse-miettes, pour les environnements +Fait de @var{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 @command{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. @xref{Invoquer guix gc}, pour plus d'informations sur les racines du GC. @item --expression=@var{expr} @itemx -e @var{expr} -Create an environment for the package or list of packages that @var{expr} -evaluates to. +Crée un environnement pour le paquet ou la liste de paquets en lesquels +s'évalue @var{expr}. -For example, running: +Par exemple, lancer : @example guix environment -e '(@@ (gnu packages maths) petsc-openmpi)' @end example -starts a shell with the environment for this specific variant of the PETSc -package. +démarre un shell avec l'environnement pour cette variante spécifique du +paquet PETSc. -Running: +Lancer : @example guix environment --ad-hoc -e '(@@ (gnu) %base-packages)' @end example -starts a shell with all the GuixSD base packages available. +démarre un shell où tous les paquets de base de GuixSD sont disponibles. -The above commands only use the default output of the given packages. To -select other outputs, two element tuples can be specified: +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 : @example guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) "include")' @end example -@item --load=@var{file} -@itemx -l @var{file} -Create an environment for the package or list of packages that the code -within @var{file} evaluates to. +@item --load=@var{fichier} +@itemx -l @var{fichier} +Crée un environnement pour le paquet ou la liste de paquets en lesquels +@var{fichier} s'évalue. Par exemple, @var{fichier} peut contenir une définition comme celle-ci (@pxref{Définition des paquets}) : @@ -7621,152 +7882,159 @@ Par exemple, @var{fichier} peut contenir une définition comme celle-ci @item --manifest=@var{fichier} @itemx -m @var{fichier} -Create an environment for the packages contained in the manifest object -returned by the Scheme code in @var{file}. +Crée un environnement pour les paquets contenus dans l'objet manifeste +renvoyé par le code Scheme dans @var{fichier}. -This is similar to the same-named option in @command{guix package} -(@pxref{profile-manifest, @option{--manifest}}) and uses the same manifest -files. +C'est similaire à l'option de même nom de @command{guix package} +(@pxref{profile-manifest, @option{--manifest}}) et utilise les même fichiers +manifestes. @item --ad-hoc -Include all specified packages in the resulting environment, as if an @i{ad -hoc} package were defined with them as inputs. This option is useful for -quickly creating an environment without having to write a package expression -to contain the desired inputs. +Inclut tous les paquets spécifiés dans l'environnement qui en résulte, comme +si un paquet @i{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. -For instance, the command: +Par exemple la commande : @example guix environment --ad-hoc guile guile-sdl -- guile @end example -runs @command{guile} in an environment where Guile and Guile-SDL are -available. +lance @command{guile} dans un environnement où Guile et Guile-SDDL sont +disponibles. -Note that this example implicitly asks for the default output of -@code{guile} and @code{guile-sdl}, but it is possible to ask for a specific -output---e.g., @code{glib:bin} asks for the @code{bin} output of @code{glib} -(@pxref{Des paquets avec plusieurs résultats}). +Remarquez que cet exemple demande implicitement la sortie par défaut de +@code{guile} et @code{guile-sdl}, mais il est possible de demander une +sortie spécifique — p.@: ex.@: @code{glib:bin} demande la sortie @code{bin} +de @code{glib} (@pxref{Des paquets avec plusieurs résultats}). -This option may be composed with the default behavior of @command{guix -environment}. Packages appearing before @code{--ad-hoc} are interpreted as -packages whose dependencies will be added to the environment, the default -behavior. Packages appearing after are interpreted as packages that will be -added to the environment directly. +Cette option peut être composée avec le comportement par défaut de +@command{guix environment}. Les paquets qui apparaissent avant +@code{--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 @code{--ad-hoc} sont interprétés comme les paquets à +ajouter à l'environnement directement. @item --pure -Unset existing environment variables when building the new environment. -This has the effect of creating an environment in which search paths only -contain package inputs. +Nettoie les variables d'environnement existantes lors de la construction du +nouvel environnement. Cela a pour effet de créer un environnement dans +lequel les chemins de recherche ne contiennent que des entrées de paquets. @item --search-paths -Display the environment variable definitions that make up the environment. +Affiche les définitions des variables d'environnement qui composent +l'environnement. @item --system=@var{système} @itemx -s @var{système} -Attempt to build for @var{system}---e.g., @code{i686-linux}. +Essaye de construire pour @var{système} — p.@: ex.@: @code{i686-linux}. @item --container @itemx -C -@cindex container -Run @var{command} within an isolated container. The current working -directory outside the container is mapped inside the container. -Additionally, unless overridden with @code{--user}, a dummy home directory -is created that matches the current user's home directory, and -@file{/etc/passwd} is configured accordingly. The spawned process runs as -the current user outside the container, but has root privileges in the -context of the container. +@cindex conteneur +Lance @var{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 @code{--user}, un répertoire personnel fictif est créé +pour correspondre à celui de l'utilisateur actuel et @file{/etc/passwod} est +configuré en conséquence. Le processus est lancé en tant que l'utilisateur +actuel en dehors du conteneur, mais a les privilèges root dans le contexte +du conteneur. @item --network @itemx -N -For containers, share the network namespace with the host system. -Containers created without this flag only have access to the loopback -device. +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. @item --link-profile @itemx -P -For containers, link the environment profile to @file{~/.guix-profile} -within the container. This is equivalent to running the command @command{ln --s $GUIX_ENVIRONMENT ~/.guix-profile} within the container. Linking will -fail and abort the environment if the directory already exists, which will -certainly be the case if @command{guix environment} was invoked in the -user's home directory. - -Certain packages are configured to look in @code{~/.guix-profile} for -configuration files and data;@footnote{For example, the @code{fontconfig} -package inspects @file{~/.guix-profile/share/fonts} for additional fonts.} -@code{--link-profile} allows these programs to behave as expected within the -environment. - -@item --user=@var{user} -@itemx -u @var{user} -For containers, use the username @var{user} in place of the current user. -The generated @file{/etc/passwd} entry within the container will contain the -name @var{user}; the home directory will be @file{/home/USER}; and no user -GECOS data will be copied. @var{user} need not exist on the system. - -Additionally, any shared or exposed path (see @code{--share} and -@code{--expose} respectively) whose target is within the current user's home -directory will be remapped relative to @file{/home/USER}; this includes the -automatic mapping of the current working directory. - -@example -# will expose paths as /home/foo/wd, /home/foo/test, and /home/foo/target +Pour les conteneurs, lie le profil de l'environnement à +@file{~/.guix-profile} dans le conteneur. C'est équivalent à lance la +commande @command{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 @command{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 @code{~/.guix-profile}@footnote{Par exemple, le paquet +@code{fontconfig} inspecte @file{~/.guix-profile/share/fonts} pour trouver +des polices supplémentaires.} ; @code{--link-profile} permet à ces +programmes de se comporter comme attendu dans l'environnement. + +@item --user=@var{utilisateur} +@itemx -u @var{utilisateur} +Pour les conteneurs, utilise le nom d'utilisateur @var{utilisateur} à la +place de l'utilisateur actuel. L'entrée générée dans @file{/etc/passwod} +dans le conteneur contiendra le nom @var{utilisateur} ; le répertoire +personnel sera @file{/home/UTILISATEUR} ; et aucune donnée GECOS ne sera +copiée. @var{utilisateur} n'a pas besoin d'exister sur le système. + +En plus, tous les chemins partagés ou exposés (voir @code{--share} et +@code{--expose} respectivement) dont la cible est dans le répertoire +personnel de l'utilisateur seront remontés relativement à +@file{/home/UTILISATEUR} ; cela comprend le montage automatique du +répertoire de travail actuel. + +@example +# 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 @end example -While this will limit the leaking of user identity through home paths and -each of the user fields, this is only one useful component of a broader -privacy/anonymity solution---not one in and of itself. +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. -@item --expose=@var{source}[=@var{target}] -For containers, expose the file system @var{source} from the host system as -the read-only file system @var{target} within the container. If -@var{target} is not specified, @var{source} is used as the target mount -point in the container. +@item --expose=@var{source}[=@var{cible}] +Pour les conteneurs, expose le système de fichiers @var{source} du système +hôte comme un système de fichiers en lecture seule @var{cible} dans le +conteneur. Si @var{cible} n'est pas spécifiée, @var{source} est utilisé +comme point de montage dans le conteneur. -The example below spawns a Guile REPL in a container in which the user's -home directory is accessible read-only via the @file{/exchange} directory: +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 @file{/exchange} : @example guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile @end example -@item --share=@var{source}[=@var{target}] -For containers, share the file system @var{source} from the host system as -the writable file system @var{target} within the container. If @var{target} -is not specified, @var{source} is used as the target mount point in the -container. +@item --share=@var{source}[=@var{cible}] +Pour les conteneurs, partage le système de fichiers @var{soruce} du système +hôte comme un système de fichiers en lecture-écriture @var{cible} dans le +conteneur. Si @var{cible} n'est pas spécifiée, @var{source} est utilisée +comme point de montage dans le conteneur. -The example below spawns a Guile REPL in a container in which the user's -home directory is accessible for both reading and writing via the -@file{/exchange} directory: +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-écriture via +le répertoire @file{/exchange} : @example guix environment --container --share=$HOME=/exchange --ad-hoc guile -- guile @end example @end table -@command{guix environment} also supports all of the common build options -that @command{guix build} supports (@pxref{Options de construction communes}). +@command{guix environment} supporte aussi toutes les options de construction +que @command{guix build} supporte (@pxref{Options de construction communes}). @node Invoquer guix publish -@section Invoking @command{guix publish} +@section Invoquer @command{guix publish} @cindex @command{guix publish} Le but de @command{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 (@pxref{Substituts}). -When @command{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 Hydra, the software behind the -@code{hydra.gnu.org} build farm. +Lorsque @command{guix publish} est lancé, il crée un serveur HTTP qui permet +à n'importe qui avec un accès réseau d'y récupérer des substituts. Cela +signifie que toutes les machines qui font tourner Guix peuvent aussi agir +comme une ferme de construction, puisque l'interface HTTP est compatible +avec Hydra, le logiciel derrière la ferme de construction +@code{hydra.gnu.org}. Pour des raisons de sécurité, chaque substitut est signé, ce qui permet aux destinataires de vérifier leur authenticité et leur intégrité @@ -7775,8 +8043,9 @@ signature du système, qui n'est lisible que par l'administrateur système, il doit être lancé en root ; l'option @code{--user} lui fait baisser ses privilèges le plus tôt possible. -The signing key pair must be generated before @command{guix publish} is -launched, using @command{guix archive --generate-key} (@pxref{Invoquer guix archive}). +La pair de clefs pour les signatures doit être générée avant de lancer +@command{guix publish}, avec @command{guix archive --generate-key} +(@pxref{Invoquer guix archive}). La syntaxe générale est : @@ -7784,169 +8053,176 @@ La syntaxe générale est : guix publish @var{options}@dots{} @end example -Running @command{guix publish} without any additional arguments will spawn -an HTTP server on port 8080: +Lancer @command{guix publish} sans arguments supplémentaires lancera un +serveur HTTP sur le port 8080 : @example guix publish @end example -Once a publishing server has been authorized (@pxref{Invoquer guix archive}), the daemon may download substitutes from it: +Une fois qu'un serveur de publication a été autorisé (@pxref{Invoquer guix archive}), le démon peut télécharger des substituts à partir de lui : @example guix-daemon --substitute-urls=http://example.org:8080 @end example -By default, @command{guix publish} compresses archives on the fly as it -serves them. This ``on-the-fly'' mode is convenient in that it requires no -setup and is immediately available. However, when serving lots of clients, -we recommend using the @option{--cache} option, which enables caching of the -archives before they are sent to clients---see below for details. The -@command{guix weather} command provides a handy way to check what a server -provides (@pxref{Invoquer guix weather}). +Par défaut, @command{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 +@option{--cache}, qui active le cache des archives avant de les envoyer aux +clients — voir les détails plus bas. La commande @command{guix weather} +fournit un manière pratique de vérifier ce qu'un serveur fournit +(@pxref{Invoquer guix weather}). -As a bonus, @command{guix publish} also serves as a content-addressed mirror -for source files referenced in @code{origin} records (@pxref{Référence d'origine}). For instance, assuming @command{guix publish} is running on -@code{example.org}, the following URL returns the raw -@file{hello-2.10.tar.gz} file with the given SHA256 hash (represented in -@code{nix-base32} format, @pxref{Invoquer guix hash}): +En bonus, @command{guix publish} sert aussi un miroir adressé par le contenu +des fichiers source référencées dans les enregistrements @code{origin} +(@pxref{Référence d'origine}). Par exemple, en supposant que @command{guix +publish} tourne sur @code{example.org}, l'URL suivante renverra le fichie +brut @file{hello-2.10.tar.gz} avec le hash SHA256 donné (représenté sous le +format @code{nix-base32}, @pxref{Invoquer guix hash}) : @example http://example.org/file/hello-2.10.tar.gz/sha256/0ssi1@dots{}ndq1i @end example -Obviously, these URLs only work for files that are in the store; in other -cases, they return 404 (``Not Found''). +Évidemment, ces URL ne fonctionnent que pour des fichiers dans le dépôt ; +dans les autres cas, elles renvoie une erreur 404 (« Introuvable »). -@cindex build logs, publication -Build logs are available from @code{/log} URLs like: +@cindex journaux de construction, publication +Les journaux de construction sont disponibles à partir des URL @code{/log} +comme ceci : @example http://example.org/log/gwspk@dots{}-guile-2.2.3 @end example @noindent -When @command{guix-daemon} is configured to save compressed build logs, as -is the case by default (@pxref{Invoquer guix-daemon}), @code{/log} URLs -return the compressed log as-is, with an appropriate @code{Content-Type} -and/or @code{Content-Encoding} header. We recommend running -@command{guix-daemon} with @code{--log-compression=gzip} since Web browsers -can automatically decompress it, which is not the case with bzip2 -compression. +Lorsque @command{guix-daemon} est configuré pour sauvegarder les journaux de +construction compressés, comme c'est le cas par défaut (@pxref{Invoquer guix-daemon}), les URL @code{/log} renvoient le journal compressé tel-quel, +avec un en-tête @code{Content-Type} ou @code{Content-Encoding} approprié. +Nous recommandons de lancer @command{guix-daemon} avec +@code{--log-compression=gzip} pace que les navigateurs web les décompressent +automatiquement, ce qui n'est pas le cas avec la compression bzip2. -The following options are available: +Les options suivantes sont disponibles : @table @code @item --port=@var{port} @itemx -p @var{port} -Listen for HTTP requests on @var{port}. - -@item --listen=@var{host} -Listen on the network interface for @var{host}. The default is to accept -connections from any interface. - -@item --user=@var{user} -@itemx -u @var{user} -Change privileges to @var{user} as soon as possible---i.e., once the server -socket is open and the signing key has been read. - -@item --compression[=@var{level}] -@itemx -C [@var{level}] -Compress data using the given @var{level}. When @var{level} is zero, -disable compression. The range 1 to 9 corresponds to different gzip -compression levels: 1 is the fastest, and 9 is the best (CPU-intensive). -The default is 3. - -Unless @option{--cache} is used, compression occurs on the fly and the -compressed streams are not cached. Thus, to reduce load on the machine that -runs @command{guix publish}, it may be a good idea to choose a low -compression level, to run @command{guix publish} behind a caching proxy, or -to use @option{--cache}. Using @option{--cache} has the advantage that it -allows @command{guix publish} to add @code{Content-Length} HTTP header to -its responses. - -@item --cache=@var{directory} -@itemx -c @var{directory} -Cache archives and meta-data (@code{.narinfo} URLs) to @var{directory} and -only serve archives that are in cache. - -When this option is omitted, archives and meta-data are created on-the-fly. -This can reduce the available bandwidth, especially when compression is -enabled, since this may become CPU-bound. Another drawback of the default -mode is that the length of archives is not known in advance, so -@command{guix publish} does not add a @code{Content-Length} HTTP header to -its responses, which in turn prevents clients from knowing the amount of -data being downloaded. - -Conversely, when @option{--cache} is used, the first request for a store -item (@i{via} a @code{.narinfo} URL) returns 404 and triggers a background -process to @dfn{bake} the archive---computing its @code{.narinfo} and -compressing the archive, if needed. Once the archive is cached in -@var{directory}, subsequent requests succeed and are served directly from -the cache, which guarantees that clients get the best possible bandwidth. - -The ``baking'' process is performed by worker threads. By default, one -thread per CPU core is created, but this can be customized. See -@option{--workers} below. - -When @option{--ttl} is used, cached entries are automatically deleted when -they have expired. +Écoute les requêtes HTTP sur le @var{port} + +@item --listen=@var{hôte} +Écoute sur l'interface réseau de @var{hôte}. Par défaut, la commande +accepte les connexions de n'importe quelle interface. + +@item --user=@var{utilisateur} +@itemx -u @var{utilisateur} +Charge les privilèges de @var{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. + +@item --compression[=@var{niveau}] +@itemx -C [@var{niveau}] +Compresse les données au @var{niveau} donné. Lorsque le @var{niveau} est +zéro, désactive la compression. L'intervalle 1 à 9 correspond aux +différents niveaux de compression gzip : 1 est le plus rapide et 9 est la +meilleure (mais gourmande en CPU). Le niveau par défaut est 3. + +À moins que @option{--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 @command{guix publish}, c'est une +bonne idée de choisir un niveau de compression faible, de lancer +@command{guix publish} derrière un serveur de cache ou d'utiliser +@option{--cache}. Utilise @option{--cache} a l'avantage qu'il permet à +@command{guix publish} d'ajouter l'en-tête HTTP @code{Content-Length} à sa +réponse. + +@item --cache=@var{répertoire} +@itemx -c @var{répertoire} +Cache les archives et les métadonnées (les URL @code{.narinfo}) dans +@var{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 @command{guix publish} n'ajoute pas l'en-tête +@code{Content-Length} à ses résponses, ce qui empêche les clients de savoir +la quantité de données à télécharger. + +À l'inverse, lorsque @option{--cache} est utilisée, la première requête pour +un élément du dépôt (via une URL @code{.narinfo}) renvoie une erreur 404 et +déclenche la création de l'archive — en calculant son @code{.narinfo} et en +compressant l'archive au besoin. Une fois l'archive cachée dans +@var{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 @option{--workers} plus bas. + +Lorsque l'option @option{--ttl} est utilisée, les entrées cachées sont +automatiquement supprimées lorsqu'elles expirent. @item --workers=@var{N} -When @option{--cache} is used, request the allocation of @var{N} worker -threads to ``bake'' archives. +Lorsque @option{--cache} est utilisée, demande l'allocation de @var{N} +thread de travail pour créer les archives. @item --ttl=@var{ttl} -Produce @code{Cache-Control} HTTP headers that advertise a time-to-live -(TTL) of @var{ttl}. @var{ttl} must denote a duration: @code{5d} means 5 -days, @code{1m} means 1 month, and so on. - -This allows the user's Guix to keep substitute information in cache for -@var{ttl}. However, note that @code{guix publish} does not itself guarantee -that the store items it provides will indeed remain available for as long as -@var{ttl}. - -Additionally, when @option{--cache} is used, cached entries that have not -been accessed for @var{ttl} and that no longer have a corresponding item in -the store, may be deleted. - -@item --nar-path=@var{path} -Use @var{path} as the prefix for the URLs of ``nar'' files (@pxref{Invoquer guix archive, normalized archives}). - -By default, nars are served at a URL such as -@code{/nar/gzip/@dots{}-coreutils-8.25}. This option allows you to change -the @code{/nar} part to @var{path}. - -@item --public-key=@var{file} -@itemx --private-key=@var{file} -Use the specific @var{file}s as the public/private key pair used to sign the -store items being published. - -The files must correspond to the same key pair (the private key is used for -signing and the public key is merely advertised in the signature metadata). -They must contain keys in the canonical s-expression format as produced by -@command{guix archive --generate-key} (@pxref{Invoquer guix archive}). By -default, @file{/etc/guix/signing-key.pub} and -@file{/etc/guix/signing-key.sec} are used. +Produit des en-têtes HTTP @code{Cache-Control} qui expriment une durée de +vie (TTL) de @var{ttl}. @var{ttl} peut dénoter une durée : @code{5d} +signifie 5 jours, @code{1m} signifie un mois, etc. + +Cela permet au Guix de l'utilisateur de garder les informations en cache +pendant @var{ttl}. Cependant, remarquez que @code{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 @var{ttl}. + +En plus, lorsque @option{--cache} est utilisée, les entrées cachées qui +n'ont pas été demandé depuis @var{ttl} et n'ont pas d'élément correspondant +dans le dépôt peuvent être supprimées. + +@item --nar-path=@var{chemin} +Utilise @var{chemin} comme préfixe des URL de fichier « nar » +(@pxref{Invoquer guix archive, normalized archives}). + +Par défaut, les nars sont présents à l'URL comme +@code{/nar/gzip/@dots{}-coreutils-8.25}. Cette option vous permet de +changer la partie @code{/nar} en @var{chemin}. + +@item --public-key=@var{fichier} +@itemx --private-key=@var{fichier} +Utilise les @var{fichier}s 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 @command{guix archive --generate-key} +(@pxref{Invoquer guix archive}). Par défaut, +@file{/etc/guix/signing-key.pub} et @file{/etc/guix/signing-key.sec} sont +utilisés. @item --repl[=@var{port}] @itemx -r [@var{port}] -Spawn a Guile REPL server (@pxref{REPL Servers,,, guile, GNU Guile Reference -Manual}) on @var{port} (37146 by default). This is used primarily for -debugging a running @command{guix publish} server. +Crée un serveur REPL Guile (@pxref{REPL Servers,,, guile, GNU Guile +Reference Manual}) sur @var{pport} (37146 par défaut). C'est surtout utile +pour déboguer un serveur @command{guix publish} qui tourne. @end table -Enabling @command{guix publish} on a GuixSD system is a one-liner: just -instantiate a @code{guix-publish-service-type} service in the -@code{services} field of the @code{operating-system} declaration +Activer @command{guix publish} sur un système GuixSD est vraiment une seule +ligne : instantiez simplement un service @code{guix-publish-service-type} +dans le champs @code{services} de votre déclaration @code{operating-system} (@pxref{guix-publish-service-type, @code{guix-publish-service-type}}). -If you are instead running Guix on a ``foreign distro'', follow these -instructions:” +Si vous avez installé Guix sur une « distro extérieure », suivez ces +instructions : @itemize @item -If your host distro uses the systemd init system: +Si votre distro hôte utilise le système d'init systemd : @example # ln -s ~root/.guix-profile/lib/systemd/system/guix-publish.service \ @@ -7963,19 +8239,21 @@ Si votre distribution hôte utilise le système d'initialisation Upstart : @end example @item -Otherwise, proceed similarly with your distro's init system. +Sinon, procédez de manière similaire avec votre système d'init de votre +distro. @end itemize @node Invoquer guix challenge -@section Invoking @command{guix challenge} +@section Invoquer @command{guix challenge} @cindex constructions reproductibles -@cindex verifiable builds +@cindex constructions vérifiables @cindex @command{guix challenge} -@cindex challenge -Do the binaries provided by this server really correspond to the source code -it claims to build? Is a package build process deterministic? These are the -questions the @command{guix challenge} command attempts to answer. +@cindex défi +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 @command{guix challenge} essaye de répondre. La première question est évidemment importante : avant d'utiliser un serveur de substituts (@pxref{Substituts}), il vaut mieux @emph{vérifier} qu'il @@ -7985,61 +8263,65 @@ 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. -We know that the hash that shows up in @file{/gnu/store} file names is the -hash of all the inputs of the process that built the file or -directory---compilers, libraries, build scripts, -etc. (@pxref{Introduction}). Assuming deterministic build processes, one -store file name should map to exactly one build output. @command{guix -challenge} checks whether there is, indeed, a single mapping by comparing -the build outputs of several independent builds of any given store item. +On sait que le hash qui apparaît dans @file{/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. (@pxref{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. @command{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é. -The command output looks like this: +La sortie de la commande ressemble à : @smallexample $ guix challenge --substitute-urls="https://hydra.gnu.org https://guix.example.org" -updating list of substitutes from 'https://hydra.gnu.org'... 100.0% -updating list of substitutes from 'https://guix.example.org'... 100.0% -/gnu/store/@dots{}-openssl-1.0.2d contents differ: - local hash: 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q - https://hydra.gnu.org/nar/@dots{}-openssl-1.0.2d: 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q - https://guix.example.org/nar/@dots{}-openssl-1.0.2d: 1zy4fmaaqcnjrzzajkdn3f5gmjk754b43qkq47llbyak9z0qjyim -/gnu/store/@dots{}-git-2.5.0 contents differ: - local hash: 00p3bmryhjxrhpn2gxs2fy0a15lnip05l97205pgbk5ra395hyha - https://hydra.gnu.org/nar/@dots{}-git-2.5.0: 069nb85bv4d4a6slrwjdy8v1cn4cwspm3kdbmyb81d6zckj3nq9f - https://guix.example.org/nar/@dots{}-git-2.5.0: 0mdqa9w1p6cmli6976v4wi0sw9r4p5prkj7lzfd1877wk11c9c73 -/gnu/store/@dots{}-pius-2.1.1 contents differ: - local hash: 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax - https://hydra.gnu.org/nar/@dots{}-pius-2.1.1: 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax - https://guix.example.org/nar/@dots{}-pius-2.1.1: 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs +mise à jour de la liste des substituts depuis 'https://hydra.gnu.org'... 100.0% +mise à jour de la liste des substituts depuis 'https://guix.example.org'... 100.0% +le contenu de /gnu/store/@dots{}-openssl-1.0.2d diffère : + empreinte locale : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q + https://hydra.gnu.org/nar/@dots{}-openssl-1.0.2d : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q + https://guix.example.org/nar/@dots{}-openssl-1.0.2d : 1zy4fmaaqcnjrzzajkdn3f5gmjk754b43qkq47llbyak9z0qjyim +le contenu de /gnu/store/@dots{}-git-2.5.0 diffère : + empreinte locale : 00p3bmryhjxrhpn2gxs2fy0a15lnip05l97205pgbk5ra395hyha + https://hydra.gnu.org/nar/@dots{}-git-2.5.0 : 069nb85bv4d4a6slrwjdy8v1cn4cwspm3kdbmyb81d6zckj3nq9f + https://guix.example.org/nar/@dots{}-git-2.5.0 : 0mdqa9w1p6cmli6976v4wi0sw9r4p5prkj7lzfd1877wk11c9c73 +le contenu de /gnu/store/@dots{}-pius-2.1.1 diffère : + empreinte locale : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax + https://hydra.gnu.org/nar/@dots{}-pius-2.1.1 : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax + https://guix.example.org/nar/@dots{}-pius-2.1.1 : 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs @dots{} -6,406 store items were analyzed: - - 4,749 (74.1%) were identical - - 525 (8.2%) differed - - 1,132 (17.7%) were inconclusive +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 @end smallexample @noindent -In this example, @command{guix challenge} first scans the store to determine -the set of locally-built derivations---as opposed to store items that were -downloaded from a substitute server---and then queries all the substitute -servers. It then reports those store items for which the servers obtained a -result different from the local build. - -@cindex non-determinism, in package builds -As an example, @code{guix.example.org} always gets a different answer. -Conversely, @code{hydra.gnu.org} agrees with local builds, except in the -case of Git. This might indicate that the build process of Git is -non-deterministic, meaning that its output varies as a function of various -things that Guix does not fully control, in spite of building packages in -isolated environments (@pxref{Fonctionnalités}). Most common sources of -non-determinism include the addition of timestamps in build results, the -inclusion of random numbers, and directory listings sorted by inode number. -See @uref{https://reproducible-builds.org/docs/}, for more information. - -To find out what is wrong with this Git binary, we can do something along -these lines (@pxref{Invoquer guix archive}): +Dans cet exemple, @command{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. + +@cindex non-déterminisme, dans les constructions des paquets +Dans l'exemple, @code{guix.example.org} obtient toujours une réponse +différente. Inversement, @code{hydra.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 (@pxref{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 +@uref{https://reproducible-builds.org/docs/}, pour plus d'informations. + +Pour trouver ce qui ne va pas avec le binaire de Git, on peut faire quelque +chose comme cela (@pxref{Invoquer guix archive}) : @example $ wget -q -O - https://hydra.gnu.org/nar/@dots{}-git-2.5.0 \ @@ -8047,96 +8329,102 @@ $ wget -q -O - https://hydra.gnu.org/nar/@dots{}-git-2.5.0 \ $ diff -ur --no-dereference /gnu/store/@dots{}-git.2.5.0 /tmp/git @end example -This command shows the difference between the files resulting from the local -build, and the files resulting from the build on @code{hydra.gnu.org} -(@pxref{Overview, Comparing and Merging Files,, diffutils, Comparing and -Merging Files}). The @command{diff} command works great for text files. -When binary files differ, a better option is @uref{https://diffoscope.org/, -Diffoscope}, a tool that helps visualize differences for all kinds of files. +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 +@code{hydra.gnu.org} (@pxref{Overview, Comparing and Merging Files,, +diffutils, Comparing and Merging Files}). La commande @command{diff} +fonctionne bien avec des fichiers texte. Lorsque des fichiers binaires +diffèrent cependant, @uref{https://diffoscope.org/, Diffoscope} est une +meilleure option. C'est un outil qui aide à visualiser les différences +entre toute sorte de fichiers. -Once you have done that work, you can tell whether the differences are due -to a non-deterministic build process or to a malicious server. We try hard -to remove sources of non-determinism in packages to make it easier to verify -substitutes, but of course, this is a process that involves not just Guix, -but a large part of the free software community. In the meantime, -@command{guix challenge} is one tool to help address the problem. +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, @command{guix challenge} est un outil +pour aider à corriger le problème. -If you are writing packages for Guix, you are encouraged to check whether -@code{hydra.gnu.org} and other substitute servers obtain the same build -result as you did with: +Si vous écrivez un paquet pour Guix, nous vous encourageons à vérifier si +@code{hydra.gnu.org} et d'autres serveurs de substituts obtiennent le même +résultat que vous avec : @example -$ guix challenge @var{package} +$ guix challenge @var{paquet} @end example @noindent -where @var{package} is a package specification such as @code{guile@@2.0} or +où @var{paquet} est une spécification de paquet comme @code{guile@@2.0} ou @code{glibc:debug}. La syntaxe générale est : @example -guix challenge @var{options} [@var{packages}@dots{}] +guix challenge @var{options} [@var{paquets}@dots{}] @end example -When a difference is found between the hash of a locally-built item and that -of a server-provided substitute, or among substitutes provided by different -servers, the command displays it as in the example above and its exit code -is 2 (other non-zero exit codes denote other kinds of errors.) +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). -The one option that matters is: +L'option qui compte est : @table @code @item --substitute-urls=@var{urls} -Consider @var{urls} the whitespace-separated list of substitute source URLs -to compare to. +Considère @var{urls} comme la liste des URL des sources de substituts +séparés par des espaces avec lesquels comparer les paquets locaux. @item --verbose @itemx -v -Show details about matches (identical contents) in addition to information -about mismatches. +Montre des détails sur les correspondances (contenu identique) en plus des +informations sur différences. @end table @node Invoquer guix copy -@section Invoking @command{guix copy} +@section Invoquer @command{guix copy} -@cindex copy, of store items, over SSH -@cindex SSH, copy of store items -@cindex sharing store items across machines -@cindex transferring store items across machines -The @command{guix copy} command copies items from the store of one machine -to that of another machine over a secure shell (SSH) -connection@footnote{This command is available only when Guile-SSH was -found. @xref{Prérequis}, for details.}. For example, the following -command copies the @code{coreutils} package, the user's profile, and all -their dependencies over to @var{host}, logged in as @var{user}: +@cindex copier des éléments du dépôt par SSH +@cindex SSH, copie d'éléments du dépôt +@cindex partager des éléments du dépôt entre plusieurs machines +@cindex transférer des éléments du dépôt entre plusieurs machines +La commande @command{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 SSH@footnote{Cette +commande n'est disponible que si Guile-SSH est trouvé. @xref{Prérequis}, +pour des détails}. Par exemple, la commande suivante copie le paquet +@code{coreutils}, le profil utilisateur et toutes leurs dépendances sur +@var{hôte}, en tant qu'utilisateur @var{utilisateur} : @example -guix copy --to=@var{user}@@@var{host} \ +guix copy --to=@var{utilisateur}@@@var{hôte} \ coreutils `readlink -f ~/.guix-profile` @end example -If some of the items to be copied are already present on @var{host}, they -are not actually sent. +Si certains éléments à copier sont déjà présents sur @var{hôte}, ils ne sont +pas envoyés. -The command below retrieves @code{libreoffice} and @code{gimp} from -@var{host}, assuming they are available there: +La commande ci-dessous récupère @code{libreoffice} et @code{gimp} depuis +@var{hôte}, en supposant qu'ils y sont présents : @example -guix copy --from=@var{host} libreoffice gimp +guix copy --from=@var{hôte} libreoffice gimp @end example -The SSH connection is established using the Guile-SSH client, which is -compatible with OpenSSH: it honors @file{~/.ssh/known_hosts} and -@file{~/.ssh/config}, and uses the SSH agent for authentication. +La connexion SSH est établie avec le client Guile-SSH, qui set compatible +avec OpenSSH : il honore @file{~/.ssh/known_hosts} et @file{~/.ssh/config} +et utilise l'agent SSH pour l'authentification. -The key used to sign items that are sent must be accepted by the remote -machine. Likewise, the key used by the remote machine to sign items you are -retrieving must be in @file{/etc/guix/acl} so it is accepted by your own -daemon. @xref{Invoquer guix archive}, for more information about store item -authentication. +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 +@file{/etc/guix/acl} pour qu'ils soient acceptés par votre propre démon. +@xref{Invoquer guix archive}, pour plus d'informations sur +l'authentification des éléments du dépôt. La syntaxe générale est : @@ -8144,36 +8432,38 @@ La syntaxe générale est : guix copy [--to=@var{spec}|--from=@var{spec}] @var{items}@dots{} @end example -You must always specify one of the following options: +Vous devez toujours spécifier l'une des options suivantes : @table @code @item --to=@var{spec} @itemx --from=@var{spec} -Specify the host to send to or receive from. @var{spec} must be an SSH spec -such as @code{example.org}, @code{charlie@@example.org}, or -@code{charlie@@example.org:2222}. +Spécifie l'hôte où envoyer ou d'où recevoir les éléments. @var{spec} doit +être une spécification SSH comme @code{example.org}, +@code{charlie@@example.org} ou @code{charlie@@example.org:2222}. @end table -The @var{items} can be either package names, such as @code{gimp}, or store -items, such as @file{/gnu/store/@dots{}-idutils-4.6}. +L'option @var{items} peut être des noms de paquets, comme @code{gimp} ou des +éléments du dépôt comme @file{/gnu/store/@dots{}-idutils-4.6}. -When specifying the name of a package to send, it is first built if needed, -unless @option{--dry-run} was specified. Common build options are supported -(@pxref{Options de construction communes}). +Lorsque vous spécifiez le nom d'un paquet à envoyer, il est d'abord +construit au besoin, sauf si l'option @option{--dry-run} est spécifiée. Les +options de construction communes sont supportées (@pxref{Options de construction communes}). @node Invoquer guix container -@section Invoking @command{guix container} -@cindex container +@section Invoquer @command{guix container} +@cindex conteneur @cindex @command{guix container} @quotation Remarque -As of version @value{VERSION}, this tool is experimental. The interface is -subject to radical change in the future. +À la version @value{VERSION}, cet outil est toujours expérimental. +L'interface est sujette à changement radicaux dans le futur. @end quotation -The purpose of @command{guix container} is to manipulate processes running -within an isolated environment, commonly known as a ``container'', typically -created by the @command{guix environment} (@pxref{Invoquer guix environment}) and @command{guix system container} (@pxref{Invoquer guix system}) commands. +Le but de @command{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 @command{guix environment} +(@pxref{Invoquer guix environment}) et @command{guix system container} +(@pxref{Invoquer guix system}). La syntaxe générale est : @@ -8181,41 +8471,41 @@ La syntaxe générale est : guix container @var{action} @var{options}@dots{} @end example -@var{action} specifies the operation to perform with a container, and -@var{options} specifies the context-specific arguments for the action. +@var{action} spécifie les opérations à effectuer avec un conteneur, et +@var{options} spécifie les arguments spécifiques au contexte pour l'action. -The following actions are available: +Les actions suivantes sont disponibles : @table @code @item exec -Execute a command within the context of a running container. +Exécute une commande dans le contexte d'un conteneur lancé. -The syntax is: +La syntaxe est : @example -guix container exec @var{pid} @var{program} @var{arguments}@dots{} +guix container exec @var{pid} @var{programme} @var{arguments}@dots{} @end example -@var{pid} specifies the process ID of the running container. @var{program} -specifies an executable file name within the root file system of the -container. @var{arguments} are the additional options that will be passed -to @var{program}. +@var{pid} spécifie le PID du conteneur lancé. @var{programme} spécifie le +nom du fichier exécutable dans le système de fichiers racine du conteneur. +@var{arguments} sont les options supplémentairesà passer à @var{programme}. -The following command launches an interactive login shell inside a GuixSD -container, started by @command{guix system container}, and whose process ID -is 9001: +La commande suivante lance un shell de connexion interactif dans un +conteneur GuixSD, démarré par @command{guix system container} et dont le PID +est 9001 : @example guix container exec 9001 /run/current-system/profile/bin/bash --login @end example -Note that the @var{pid} cannot be the parent process of a container. It -must be PID 1 of the container or one of its child processes. +Remarquez que @var{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. @end table @node Invoquer guix weather -@section Invoking @command{guix weather} +@section Invoquer @command{guix weather} Vous pouvez parfois grogner lorsque les substituts ne sont pas disponibles et que vous devez construire les paquets vous-même (@pxref{Substituts}). La @@ -8225,70 +8515,73 @@ aujourd'hui. Cela peut parfois être une information utile pour les utilisateurs, mais elle est surtout utile pour les personnes qui font tourner @command{guix publish} (@pxref{Invoquer guix publish}). -@cindex statistics, for substitutes -@cindex availability of substitutes -@cindex substitute availability -@cindex weather, substitute availability -Here's a sample run: +@cindex statistiques sur les substituts +@cindex disponibilité des substituts +@cindex substuts, disponibilité +@cindex weather, disponibilité des substituts +Voici un exemple : @example $ guix weather --substitute-urls=https://guix.example.org -computing 5,872 package derivations for x86_64-linux... -looking for 6,128 store items on https://guix.example.org.. -updating list of substitutes from 'https://guix.example.org'... 100.0% +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% substitutes available (2,658 out of 6,128) - 7,032.5 MiB of nars (compressed) - 19,824.2 MiB on disk (uncompressed) - 0.030 seconds per request (182.9 seconds in total) - 33.5 requests per second - - 9.8% (342 out of 3,470) of the missing items are queued - 867 queued builds - x86_64-linux: 518 (59.7%) - i686-linux: 221 (25.5%) - aarch64-linux: 128 (14.8%) - build rate: 23.41 builds per hour - x86_64-linux: 11.16 builds per hour - i686-linux: 6.03 builds per hour - aarch64-linux: 6.41 builds per hour -@end example - -@cindex continuous integration, statistics -As you can see, it reports the fraction of all the packages for which -substitutes are available on the server---regardless of whether substitutes -are enabled, and regardless of whether this server's signing key is -authorized. It also reports the size of the compressed archives (``nars'') -provided by the server, the size the corresponding store items occupy in the -store (assuming deduplication is turned off), and the server's throughput. -The second part gives continuous integration (CI) statistics, if the server -supports it. - -To achieve that, @command{guix weather} queries over HTTP(S) meta-data -(@dfn{narinfos}) for all the relevant store items. Like @command{guix -challenge}, it ignores signatures on those substitutes, which is innocuous -since the command only gathers statistics and cannot install those -substitutes. - -Among other things, it is possible to query specific system types and -specific package sets. The available options are listed below. + 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 +@end example + +@cindex intégration continue, statistiques +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 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. + +Pour cela, @command{guix weather} récupère par HTTP(S) les métadonnées +(@dfn{narinfos}@ de tous les éléments du dépôts pertinents. Comme +@command{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. + +Entre autres choses, il est possible de demander des types de système +particuliers et des ensembles de paquets particuliers. Les options +disponibles sont listées plus bas. @table @code @item --substitute-urls=@var{urls} -@var{urls} is the space-separated list of substitute server URLs to query. -When this option is omitted, the default set of substitute servers is -queried. +@var{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é. @item --system=@var{système} @itemx -s @var{système} -Query substitutes for @var{system}---e.g., @code{aarch64-linux}. This -option can be repeated, in which case @command{guix weather} will query -substitutes for several system types. +Effectue des requêtes pour les substituts @var{système} — p.@: ex.@: +@code{aarch64-linux}. Cette option peut être répétée, auquel cas +@command{guix weather} demandera les substituts de plusieurs types de +systèmes. @item --manifest=@var{fichier} -Instead of querying substitutes for all the packages, only ask for those -specified in @var{file}. @var{file} must contain a @dfn{manifest}, as with -the @code{-m} option of @command{guix package} (@pxref{Invoquer guix package}). +Plutôt que de demander des substituts pour tous les paquets, demande +uniquement les paquets spécifiés dans @var{fichier}. @var{fichier} doit +contenir un @dfn{manifeste} comme avec l'option @code{-m} de @command{guix +package} (@pxref{Invoquer guix package}). @end table @@ -8298,14 +8591,14 @@ the @code{-m} option of @command{guix package} (@pxref{Invoquer guix package}). @cindex Distribution Système Guix @cindex GuixSD -Guix comes with a distribution of the GNU system consisting entirely of free -software@footnote{The term ``free'' here refers to the -@url{http://www.gnu.org/philosophy/free-sw.html,freedom provided to users of -that software}.}. The distribution can be installed on its own -(@pxref{Installation du système}), but it is also possible to install Guix as a -package manager on top of an installed GNU/Linux system -(@pxref{Installation}). To distinguish between the two, we refer to the -standalone distribution as the Guix System Distribution, or GuixSD. +Guix fournit aussi une distribution du système GNU contenant uniquement des +logiciels libres@footnote{Le terme « libre » se réfère ici bien sûr à +@url{http://www.gnu.org/philosophy/free-sw.fr.html,la liberté offerte à +l'utilisateur de ces logiciels}.}. On peut installer la distribution +elle-même (@pxref{Installation du système}), mais on peut aussi installer Guix +comme gestionnaire de paquets par dessus un système GNU/Linux déjà installé +(@pxref{Installation}). Pour distinguer ces deux cas, on appelle la +distribution autonome « Distribution Système Guix » ou GuixSD. The distribution provides core GNU packages such as GNU libc, GCC, and Binutils, as well as many GNU and non-GNU applications. The complete list @@ -8434,7 +8727,7 @@ More and more system services are provided (@pxref{Services}), but some may be missing. @item -More than 6,500 packages are available, but you might occasionally find that +More than 7,500 packages are available, but you might occasionally find that a useful package is missing. @item @@ -8487,7 +8780,7 @@ their support in GNU/Linux. An ISO-9660 installation image that can be written to a USB stick or burnt to a DVD can be downloaded from -@indicateurl{ftp://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz}, +@indicateurl{https://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz}, where @var{system} is one of: @table @code @@ -8503,7 +8796,7 @@ Make sure to download the associated @file{.sig} file and to verify the authenticity of the image against it, along these lines: @example -$ wget ftp://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz.sig +$ wget https://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz.sig $ gpg --verify guixsd-install-@value{VERSION}.@var{system}.iso.xz.sig @end example @@ -8739,25 +9032,36 @@ Partition} (ESP) is required. This partition should be mounted at parted /dev/sda set 1 esp on @end example +@quotation Remarque +@vindex grub-bootloader +@vindex grub-efi-bootloader +Unsure whether to use EFI- or BIOS-based GRUB? If the directory +@file{/sys/firmware/efi} exists in the installation image, then you should +probably perform an EFI installation, using @code{grub-efi-bootloader}. +Otherwise you should use the BIOS-based GRUB, known as +@code{grub-bootloader}. @xref{Configuration du chargeur d'amorçage}, for more info on +bootloaders. +@end quotation + Once you are done partitioning the target hard disk drive, you have to create a file system on the relevant partition(s)@footnote{Currently GuixSD only supports ext4 and btrfs file systems. In particular, code that reads file system UUIDs and labels only works for these file system types.}. For -the ESP, if you have one and assuming it is @file{/dev/sda2}, run: +the ESP, if you have one and assuming it is @file{/dev/sda1}, run: @example -mkfs.fat -F32 /dev/sda2 +mkfs.fat -F32 /dev/sda1 @end example Preferably, assign file systems a label so that you can easily and reliably refer to them in @code{file-system} declarations (@pxref{Systèmes de fichiers}). This is typically done using the @code{-L} option of @command{mkfs.ext4} and related commands. So, assuming the target root partition lives at -@file{/dev/sda1}, a file system with the label @code{my-root} can be created +@file{/dev/sda2}, a file system with the label @code{my-root} can be created with: @example -mkfs.ext4 -L my-root /dev/sda1 +mkfs.ext4 -L my-root /dev/sda2 @end example @cindex encrypted disk @@ -8765,12 +9069,12 @@ If you are instead planning to encrypt the root partition, you can use the Cryptsetup/LUKS utilities to do that (see @inlinefmtifelse{html, @uref{https://linux.die.net/man/8/cryptsetup, @code{man cryptsetup}}, @code{man cryptsetup}} for more information.) Assuming you want to store -the root partition on @file{/dev/sda1}, the command sequence would be along +the root partition on @file{/dev/sda2}, the command sequence would be along these lines: @example -cryptsetup luksFormat /dev/sda1 -cryptsetup open --type luks /dev/sda1 my-partition +cryptsetup luksFormat /dev/sda2 +cryptsetup open --type luks /dev/sda2 my-partition mkfs.ext4 -L my-root /dev/mapper/my-partition @end example @@ -8790,11 +9094,11 @@ system init} afterwards. Finally, if you plan to use one or more swap partitions (@pxref{Memory Concepts, swap space,, libc, The GNU C Library Reference Manual}), make sure to initialize them with @command{mkswap}. Assuming you have one swap -partition on @file{/dev/sda2}, you would run: +partition on @file{/dev/sda3}, you would run: @example -mkswap /dev/sda2 -swapon /dev/sda2 +mkswap /dev/sda3 +swapon /dev/sda3 @end example Alternatively, you may use a swap file. For example, assuming that in the @@ -9068,6 +9372,28 @@ Below we discuss the effect of some of the most important fields fields), and how to @dfn{instantiate} the operating system using @command{guix system}. +@unnumberedsubsubsec Bootloader + +@cindex legacy boot, on Intel machines +@cindex BIOS boot, on Intel machines +@cindex UEFI boot +@cindex EFI boot +The @code{bootloader} field describes the method that will be used to boot +your system. Machines based on Intel processors can boot in ``legacy'' BIOS +mode, as in the example above. However, more recent machines rely instead +on the @dfn{Unified Extensible Firmware Interface} (UEFI) to boot. In that +case, the @code{bootloader} field should contain something along these +lines: + +@example +(bootloader-configuration + (bootloader grub-efi-bootloader) + (target "/boot/efi")) +@end example + +@xref{Configuration du chargeur d'amorçage}, for more information on the available +configuration options. + @unnumberedsubsubsec Globally-Visible Packages @vindex %base-packages @@ -9173,9 +9499,8 @@ this: @include os-config-desktop.texi @end lisp -@cindex UEFI -A graphical UEFI system with a choice of lightweight window managers instead -of full-blown desktop environments would look like this: +A graphical system with a choice of lightweight window managers instead of +full-blown desktop environments would look like this: @lisp @include os-config-lightweight-desktop.texi @@ -10007,7 +10332,7 @@ core services, that may be used in an @code{operating-system} declaration. * Services VPN:: Démons VPN * Système de fichiers en réseau:: Services liés à NFS@. * Intégration continue:: Le service Cuirass. -* Services de gestion de l'énergie:: L'outil TLP@. +* Power Management Services:: Extending battery life. * Services audio:: MPD@. * Services de virtualisation:: Services de virtualisation. * Services de contrôle de version:: Fournit des accès distants à des @@ -10836,6 +11161,21 @@ job definitions that are passed to mcron (@pxref{G-Expressions}). more information on mcron job specifications. Below is the reference of the mcron service. +On a running system, you can use the @code{schedule} action of the service +to visualize the mcron jobs that will be executed next: + +@example +# herd schedule mcron +@end example + +@noindent +The example above lists the next five tasks that will be executed, but you +can also specify the number of tasks to display: + +@example +# herd schedule mcron 10 +@end example + @deffn {Scheme Procedure} mcron-service @var{jobs} [#:mcron @var{mcron}] Return an mcron service running @var{mcron} that schedules @var{jobs}, a list of gexps denoting mcron job specifications. @@ -11035,7 +11375,7 @@ This is the type for statically-configured network interfaces. @end defvr @deffn {Scheme Procedure} static-networking-service @var{interface} @var{ip} @ - [#:netmask #f] [#:gateway #f] [#:name-servers @code{'()}] [#:requirement + [#:netmask #f] [#:gateway #f] [#:name-servers @code{'()}] @ [#:requirement @code{'(udev)}] Return a service that starts @var{interface} with address @var{ip}. If @var{netmask} is true, use it as the network mask. If @var{gateway} is true, it must be a string specifying the default network @@ -11534,6 +11874,15 @@ used only by protocol version 2. When true, forwarding of X11 graphical client connections is enabled---in other words, @command{ssh} options @option{-X} and @option{-Y} will work. +@item @code{allow-agent-forwarding?} (default: @code{#t}) +Whether to allow agent forwarding. + +@item @code{allow-tcp-forwarding?} (default: @code{#t}) +Whether to allow TCP forwarding. + +@item @code{gateway-ports?} (default: @code{#f}) +Whether to allow gateway ports. + @item @code{challenge-response-authentication?} (default: @code{#f}) Specifies whether challenge response authentication is allowed (e.g. via PAM). @@ -12033,17 +12382,21 @@ connections to the print server. Suppose you want to enable the Web interface of CUPS and also add support for Epson printers @i{via} the @code{escpr} package and for HP printers -@i{via} the @code{hplip} package. You can do that directly, like this (you -need to use the @code{(gnu packages cups)} module): +@i{via} the @code{hplip-minimal} package. You can do that directly, like +this (you need to use the @code{(gnu packages cups)} module): @example (service cups-service-type (cups-configuration (web-interface? #t) (extensions - (list cups-filters escpr hplip)))) + (list cups-filters escpr hplip-minimal)))) @end example +Note: If you wish to use the Qt5 based GUI which comes with the hplip +package then it is suggested that you install the @code{hplip} package, +either in your OS configuration file or as your user. + The available configuration parameters follow. Each parameter definition is preceded by its type; for example, @samp{string-list foo} indicates that the @code{foo} parameter should be specified as a list of strings. There is @@ -13135,13 +13488,14 @@ Users need to be in the @code{lp} group to access the D-Bus service. @cindex ALSA @cindex PulseAudio, sound support -The @code{(gnu services sound)} module provides an @code{alsa-service-type} -service to generate an ALSA @file{/etc/asound.conf} configuration file. -This configuration file is what allows applications that produce sound using -ALSA to be correctly handled. +The @code{(gnu services sound)} module provides a service to configure the +Advanced Linux Sound Architecture (ALSA) system, which making PulseAudio the +prefered ALSA output driver. @deffn {Variable Scheme} alsa-service-type -This is the type for the @uref{https://alsa-project.org/, ALSA}, +This is the type for the @uref{https://alsa-project.org/, Advanced Linux +Sound Architecture} (ALSA) system, which generates the +@file{/etc/asound.conf} configuration file. The value for this type is a @command{alsa-configuration} record as in this example: @example @@ -13155,6 +13509,9 @@ See below for details about @code{alsa-configuration}. Data type representing the configuration for @code{alsa-service}. @table @asis +@item @code{alsa-plugins} (default: @var{alsa-plugins}) +@code{alsa-plugins} package to use. + @item @code{pulseaudio?} (par défaut : @code{#t}) Whether ALSA applications should transparently be made to use the @uref{http://www.pulseaudio.org/, PulseAudio} sound server. @@ -13164,11 +13521,47 @@ the same time and to individual control them @i{via} @command{pavucontrol}, among other things. @item @code{extra-options} (par défaut : @code{""}) -String to append to the @file{asound.conf} file. +String to append to the @file{/etc/asound.conf} file. @end table @end deftp +Individual users who want to override the system configuration of ALSA can +do it with the @file{~/.asoundrc} file: + +@example +# In guix, we have to specify the absolute path for plugins. +pcm_type.jack @{ + lib "/home/alice/.guix-profile/lib/alsa-lib/libasound_module_pcm_jack.so" +@} + +# Routing ALSA to 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" + @} +@} +@end example + +See @uref{https://www.alsa-project.org/main/index.php/Asoundrc} for the +details. + + @node Services de bases de données @subsubsection Services de bases de données @@ -15467,6 +15860,39 @@ is accessed via a reverse proxy. @end table @end deftp +@subsubheading Prometheus Node Exporter Service + +@cindex prometheus-node-exporter +The Prometheus ``node exporter'' makes hardware and operating system +statistics provided by the Linux kernel available for the Prometheus +monitoring system. This service should be deployed on all physical nodes +and virtual machines, where monitoring these statistics is desirable. + +@defvar {Scheme variable} prometheus-node-exporter-service-type +This is the service type for the +@uref{https://github.com/prometheus/node_exporter/, +prometheus-node-exporter} service, its value must be a +@code{prometheus-node-exporter-configuration} record as in this example: + +@example +(service prometheus-node-exporter-service-type + (prometheus-node-exporter-configuration + (web-listen-address ":9100"))) +@end example +@end defvar + +@deftp {Data Type} prometheus-node-exporter-configuration +Data type representing the configuration of @command{node_exporter}. + +@table @asis +@item @code{package} (default: @code{go-github-com-prometheus-node-exporter}) +The prometheus-node-exporter package to use. + +@item @code{web-listen-address} (default: @code{":9100"}) +Bind the web interface to the specified address. + +@end table +@end deftp @node Services Kerberos @subsubsection Services Kerberos @@ -17320,9 +17746,9 @@ The local NFSv4 domain name. This must be a string or @code{#f}. If it is @subsubsection Intégration continue @cindex continuous integration -@uref{https://notabug.org/mthl/cuirass, Cuirass} est un outil d'intégration -continue pour Guix. On peut l'utiliser aussi bien pour le développement que -pour fournir des substituts à d'autres (@pxref{Substituts}). +@uref{https://git.savannah.gnu.org/cgit/guix/guix-cuirass.git, Cuirass} is a +continuous integration tool for Guix. It can be used both for development +and for providing substitutes to others (@pxref{Substituts}). The @code{(gnu services cuirass)} module provides the following service. @@ -17381,7 +17807,7 @@ added specifications. @item @code{port} (default: @code{8081}) Port number used by the HTTP server. -@item --listen=@var{host} +@item --listen=@var{hôte} Listen on the network interface for @var{host}. The default is to accept connections from localhost. @@ -17402,19 +17828,18 @@ Only evaluate specifications and build derivations once. When substituting a pre-built binary fails, fall back to building packages locally. -@item @code{load-path} (default: @code{'()}) -This allows users to define their own packages and make them visible to -cuirass as in @command{guix build} command. - @item @code{cuirass} (default: @code{cuirass}) The Cuirass package to use. @end table @end deftp -@node Services de gestion de l'énergie -@subsubsection Services de gestion de l'énergie +@node Power Management Services +@subsubsection Power Management Services +@cindex tlp @cindex power management with TLP +@subsubheading TLP daemon + The @code{(gnu services pm)} module provides a Guix service definition for the Linux power management tool TLP. @@ -17911,6 +18336,9 @@ Defaults to @samp{#f}. @end deftypevr +@cindex thermald +@cindex CPU frequency scaling with thermald +@subsubheading Thermald daemon The @code{(gnu services pm)} module provides an interface to thermald, a CPU frequency scaling service which helps prevent overheating. @@ -19662,51 +20090,51 @@ Defaults to @samp{""}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-commit-graph? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-commit-graph? A flag which can be used to disable the global setting @code{enable-commit-graph?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-log-filecount? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-log-filecount? A flag which can be used to disable the global setting @code{enable-log-filecount?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-log-linecount? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-log-linecount? A flag which can be used to disable the global setting @code{enable-log-linecount?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-remote-branches? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-remote-branches? Flag which, when set to @code{#t}, will make cgit display remote branches in the summary and refs views. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-subject-links? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-subject-links? A flag which can be used to override the global setting @code{enable-subject-links?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-html-serving? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-html-serving? A flag which can be used to override the global setting @code{enable-html-serving?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr @@ -20482,20 +20910,33 @@ The type of a bootloader configuration declaration. The bootloader to use, as a @code{bootloader} object. For now @code{grub-bootloader}, @code{grub-efi-bootloader}, @code{extlinux-bootloader} and @code{u-boot-bootloader} are supported. + +@vindex grub-efi-bootloader @code{grub-efi-bootloader} allows to boot on modern systems using the -@dfn{Unified Extensible Firmware Interface} (UEFI). +@dfn{Unified Extensible Firmware Interface} (UEFI). This is what you should +use if the installation image contains a @file{/sys/firmware/efi} directory +when you boot it on your system. + +@vindex grub-bootloader +@code{grub-bootloader} allows you to boot in particular Intel-based machines +in ``legacy'' BIOS mode. +@cindex ARM, bootloaders +@cindex AArch64, bootloaders Available bootloaders are described in @code{(gnu bootloader @dots{})} -modules. +modules. In particular, @code{(gnu bootloader u-boot)} contains definitions +of bootloaders for a wide range of ARM and AArch64 systems, using the +@uref{http://www.denx.de/wiki/U-Boot/, U-Boot bootloader}. @item @code{target} This is a string denoting the target onto which to install the bootloader. -The exact interpretation depends on the bootloader in question; for + +The interpretation depends on the bootloader in question. For @code{grub-bootloader}, for example, it should be a device name understood by the bootloader @command{installer} command, such as @code{/dev/sda} or -@code{(hd0)} (for GRUB, @pxref{Invoking grub-install,,, grub, GNU GRUB -Manual}). For @code{grub-efi-bootloader}, it should be the path to a -mounted EFI file system. +@code{(hd0)} (@pxref{Invoking grub-install,,, grub, GNU GRUB Manual}). For +@code{grub-efi-bootloader}, it should be the mount point of the EFI file +system, usually @file{/boot/efi}. @item @code{menu-entries} (default: @code{()}) A possibly empty list of @code{menu-entry} objects (see below), denoting @@ -20519,8 +20960,8 @@ The output terminals used for the bootloader boot menu, as a list of symbols. GRUB accepts the values: @code{console}, @code{serial}, @code{serial_@{0-3@}}, @code{gfxterm}, @code{vga_text}, @code{mda_text}, @code{morse}, and @code{pkmodem}. This field corresponds to the GRUB -variable GRUB_TERMINAL_OUTPUT (@pxref{Simple configuration,,, grub,GNU GRUB -manual}). +variable @code{GRUB_TERMINAL_OUTPUT} (@pxref{Simple configuration,,, +grub,GNU GRUB manual}). @item @code{terminal-inputs} (default: @code{'()}) The input terminals used for the bootloader boot menu, as a list of @@ -20528,7 +20969,8 @@ symbols. For GRUB, the default is the native platform terminal as determined at run-time. GRUB accepts the values: @code{console}, @code{serial}, @code{serial_@{0-3@}}, @code{at_keyboard}, and @code{usb_keyboard}. This field corresponds to the GRUB variable -GRUB_TERMINAL_INPUT (@pxref{Simple configuration,,, grub,GNU GRUB manual}). +@code{GRUB_TERMINAL_INPUT} (@pxref{Simple configuration,,, grub,GNU GRUB +manual}). @item @code{serial-unit} (default: @code{#f}) The serial unit used by the bootloader, as an integer from 0 to 3. For @@ -20860,7 +21302,7 @@ give the container additional permissions. For example, if you intend to build software using Guix inside of the Docker container, you may need to pass the @option{--privileged} option to @code{docker run}. -@item container +@item conteneur Return a script to run the operating system declared in @var{file} within a container. Containers are a set of lightweight isolation mechanisms provided by the kernel Linux-libre. Containers are substantially less @@ -20929,10 +21371,10 @@ When this option is omitted, @command{guix system} computes an estimate of the image size as a function of the size of the system declared in @var{file}. -@item --root=@var{file} -@itemx -r @var{file} -Make @var{file} a symlink to the result, and register it as a garbage -collector root. +@item --root=@var{fichier} +@itemx -r @var{fichier} +Fait de @var{fichier} un lien symbolique vers le résultat, et l'enregistre +en tant que racine du ramasse-miettes. @item --skip-checks Skip pre-installation safety checks. @@ -21028,7 +21470,7 @@ shepherd services of the operating system defined in @var{file}. @cindex virtual machine To run GuixSD in a virtual machine (VM), one can either use the pre-built GuixSD VM image distributed at -@indicateurl{ftp://alpha.gnu.org/guix/guixsd-vm-image-@value{VERSION}.@var{system}.tar.xz} +@indicateurl{https://alpha.gnu.org/gnu/guix/guixsd-vm-image-@value{VERSION}.@var{system}.xz} , or build their own virtual machine image using @command{guix system vm-image} (@pxref{Invoquer guix system}). The returned image is in qcow2 format, which the @uref{http://qemu.org/, QEMU emulator} can efficiently @@ -21608,6 +22050,17 @@ to start and stop processes (@pxref{Service De- and Constructors,,, shepherd, The GNU Shepherd Manual}). They are given as G-expressions that get expanded in the Shepherd configuration file (@pxref{G-Expressions}). +@item @code{actions} (default: @code{'()}) +@cindex actions, of Shepherd services +This is a list of @code{shepherd-action} objects (see below) defining +@dfn{actions} supported by the service, in addition to the standard +@code{start} and @code{stop} actions. Actions listed here become available +as @command{herd} sub-commands: + +@example +herd @var{action} @var{service} [@var{arguments}@dots{}] +@end example + @item @code{documentation} A documentation string, as shown when running: @@ -21625,6 +22078,55 @@ This is the list of modules that must be in scope when @code{start} and @end table @end deftp +@deftp {Data Type} shepherd-action +This is the data type that defines additional actions implemented by a +Shepherd service (see above). + +@table @code +@item name +Symbol naming the action. + +@item documentation +This is a documentation string for the action. It can be viewed by running: + +@example +herd doc @var{service} action @var{action} +@end example + +@item procedure +This should be a gexp that evaluates to a procedure of at least one +argument, which is the ``running value'' of the service (@pxref{Slots of +services,,, shepherd, The GNU Shepherd Manual}). +@end table + +The following example defines an action called @code{say-hello} that kindly +greets the user: + +@example +(shepherd-action + (name 'say-hello) + (documentation "Say hi!") + (procedure #~(lambda (running . args) + (format #t "Hello, friend! arguments: ~s\n" + args) + #t))) +@end example + +Assuming this action is added to the @code{example} service, then you can +do: + +@example +# herd say-hello example +Hello, friend! arguments: () +# herd say-hello example a b c +Hello, friend! arguments: ("a" "b" "c") +@end example + +This, as you can see, is a fairly sophisticated way to say hello. +@xref{Service Convenience,,, shepherd, The GNU Shepherd Manual}, for more +info on actions. +@end deftp + @defvr {Scheme Variable} shepherd-root-service-type The service type for the Shepherd ``root service''---i.e., PID@tie{}1. @@ -21768,7 +22270,7 @@ check whether a package has a @code{debug} output, use @command{guix package @section Mises à jour de sécurité @cindex security updates -@cindex security vulnerabilities +@cindex vulnérabilités Occasionally, important security vulnerabilities are discovered in software packages and must be patched. Guix developers try hard to keep track of known vulnerabilities and to apply fixes as soon as possible in the diff --git a/doc/guix.texi b/doc/guix.texi index 85f51210a3..d2d278df47 100644 --- a/doc/guix.texi +++ b/doc/guix.texi @@ -170,7 +170,7 @@ Programming Interface Defining Packages -* package Reference :: The package data type. +* package Reference:: The package data type. * origin Reference:: The origin data type. Utilities @@ -3522,7 +3522,7 @@ when @var{cut?} returns true for a given package. @end deffn @menu -* package Reference :: The package data type. +* package Reference:: The package data type. * origin Reference:: The origin data type. @end menu @@ -6661,6 +6661,11 @@ The value associated with a flag has to be either the symbol has to conform to the Cabal file format definition. The default value associated with the keys @code{os}, @code{arch} and @code{impl} is @samp{linux}, @samp{x86_64} and @samp{ghc}, respectively. +@item --recursive +@itemx -r +Traverse the dependency graph of the given upstream package recursively +and generate package expressions for all those packages that are not yet +in Guix. @end table The command below imports metadata for the latest version of the @@ -8620,7 +8625,7 @@ more information. @subsubsection Networking -Run the following command see what your network interfaces are called: +Run the following command to see what your network interfaces are called: @example ifconfig -a @@ -8887,8 +8892,8 @@ path is actually mounted. @item Be sure that your file system labels match the value of their respective @code{device} fields in your @code{file-system} configuration, assuming -your @code{file-system} configuration sets the value of @code{title} to -@code{'label}. +your @code{file-system} configuration uses the @code{file-system-label} +procedure in its @code{device} field. @item If there are encrypted or RAID partitions, make sure to add a @@ -9266,8 +9271,8 @@ generations available on disk. It is also possible to roll back the system via the commands @command{guix system roll-back} and @command{guix system switch-generation}. -Although the command @command{guix system reconfigure} will not modify -previous generations, must take care when the current generation is not +Although the @command{guix system reconfigure} command will not modify +previous generations, you must take care when the current generation is not the latest (e.g., after invoking @command{guix system roll-back}), since the operation might overwrite a later generation (@pxref{Invoking guix system}). @@ -20056,51 +20061,51 @@ Defaults to @samp{""}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-commit-graph? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-commit-graph? A flag which can be used to disable the global setting @code{enable-commit-graph?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-log-filecount? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-log-filecount? A flag which can be used to disable the global setting @code{enable-log-filecount?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-log-linecount? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-log-linecount? A flag which can be used to disable the global setting @code{enable-log-linecount?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-remote-branches? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-remote-branches? Flag which, when set to @code{#t}, will make cgit display remote branches in the summary and refs views. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-subject-links? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-subject-links? A flag which can be used to override the global setting @code{enable-subject-links?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-html-serving? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-html-serving? A flag which can be used to override the global setting @code{enable-html-serving?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr @@ -20326,6 +20331,37 @@ An association list specifies kernel parameters and their values. @end table @end deftp +@cindex pcscd +@subsubheading PC/SC Smart Card Daemon Service + +The @code{(gnu services security-token)} module provides the following service +to run @command{pcscd}, the PC/SC Smart Card Daemon. @command{pcscd} is the +daemon program for pcsc-lite and the MuscleCard framework. It is a resource +manager that coordinates communications with smart card readers, smart cards +and cryptographic tokens that are connected to the system. + +@defvr {Scheme Variable} pcscd-service-type +Service type for the @command{pcscd} service. Its value must be a +@code{pcscd-configuration} object. To run pcscd in the default +configuration, instantiate it as: + +@example +(service pcscd-service-type) +@end example +@end defvr + +@deftp {Data Type} pcscd-configuration +The data type representing the configuration of @command{pcscd}. + +@table @asis +@item @code{pcsc-lite} (default: @code{pcsc-lite}) +The pcsc-lite package that provides pcscd. +@item @code{usb-drivers} (default: @code{(list ccid)}) +List of packages that provide USB drivers to pcscd. Drivers are expected to be +under @file{pcsc/drivers} in the store directory of the package. +@end table +@end deftp + @cindex lirc @subsubheading Lirc Service |