Options de construction supplémentaires (Manuel de référence de GNU Guix)

10.1.3 Options de construction supplémentaires

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

--quiet

-q

Construire silencieusement, sans afficher les journaux de construction ; c’est équivalent à --verbosity=0. À la fin, le journal de construction est gardé dans /var (ou similaire) et on peut toujours l’y trouver avec l’option --log-file.

--file=fichier

-f fichier

Construit le paquet, la dérivation ou l’objet simili-fichier en lequel le code dans file s’évalue (voir file-like objects).

Par exemple, file peut contenir une définition de paquet comme ceci (voir Définition des paquets) :

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

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

file peut également contenir une représentation JSON d’une ou plusieurs définitions de paquets. L’exécution de guix build -f sur hello.json avec le contenu suivant entraînerait la construction des paquets myhello et greeter :

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

--manifest=manifest

-m manifest

Construire tous les paquets listés dans un manifest donné (voir --manifest).

--expression=expr

-e expr

Construit le paquet ou la dérivation en lequel expr s’évalue.

Par exemple, expr peut être (@ (gnu packages guile) guile-1.8), qui désigne sans ambiguïté cette variante spécifique de la version 1.8 de Guile.

Autrement, exp peut être une G-expression, auquel cas elle est utilisée comme un programme de construction passé à gexp->derivation (voir G-Expressions).

Enfin, expr peut se référer à une procédure monadique à au moins un argument (voir La monade du dépôt). La procédure doit renvoyer une dérivation comme une valeur monadique, qui est ensuite lancée à travers run-with-store.

--source

-S

Construit les dérivation source des paquets, plutôt que des paquets eux-mêmes.

Par exemple, guix build -S gcc renvoie quelque chose comme /gnu/store/…-gcc-4.7.2.tar.bz2, qui est l’archive des sources de GCC.

L’archive des sources renvoyée est le résultat de l’application des correctifs et des extraits de code éventuels spécifiés dans le champ origin du paquet (voir Définition des paquets).

Comme avec les autres dérivations, le résultat de la construction des sources peut être vérifié avec l’option --check (voir vérification de la construction). C’est utile pour valider que les source (éventuellement déjà construites ou substituées, donc en cache) correspondent au hash déclaré.

Notez que guix build -S compile seulement les sources des paquets spécifiés. Les sources de dépendances statiquement liées ne sont pas incluses et sont en elles-mêmes insuffisantes pour reproduire les paquets.

--sources

Récupère et renvoie la source de package-or-derivation et toute ses dépendances, récursivement. C’est pratique pour obtenir une copie locale de tous les codes sources requis pour construire packages, ce qui vous permet de les construire plus tard même sans accès au réseau. C’est une extension de l’option --source et elle peut accepter l’un des arguments facultatifs suivants :

package

Cette valeur fait que l’option --sources se comporte comme l’option --source.

all

Construit les dérivations des sources de tous les paquets, dont les sources qui pourraient être listées dans inputs. C’est la valeur par défaut.

$ guix build --sources tzdata
The following derivations will be built:
   /gnu/store/…-tzdata2015b.tar.gz.drv
   /gnu/store/…-tzcode2015b.tar.gz.drv

transitive

Construire les dérivations des sources de tous les paquets, ainsi que toutes celles des entrées transitives des paquets. On peut par exemple utiliser cette option pour précharger les sources des paquets pour les construire plus tard hors ligne.

$ guix build --sources=transitive tzdata
The following derivations will be built:
   /gnu/store/…-tzcode2015b.tar.gz.drv
   /gnu/store/…-findutils-4.4.2.tar.xz.drv
   /gnu/store/…-grep-2.21.tar.xz.drv
   /gnu/store/…-coreutils-8.23.tar.xz.drv
   /gnu/store/…-make-4.1.tar.xz.drv
   /gnu/store/…-bash-4.3.tar.xz.drv
…

--system=système

-s système

Essayer de construire pour system — p. ex. i686-linux — au lieu du type de système de l’hôte. La commande guix build vous permet de répéter cette option plusieurs fois, auquel cas elle construit pour tous les systèmes spécifiés ; les autres commandes ignorent les options -s supplémentaires.

Remarque : Le drapeau --system est utilisé pour une compilation native et ne doit pas être confondu avec une compilation croisée. Voir --target ci-dessous pour des informations sur la compilation croisée.

Un exemple d’utilisation de ceci sur les systèmes Linux, qui peut émuler différentes personnalités. Par exemple, passer --system=i686-linux sur un système x86_64-linux ou --system=armhf-linux sur un système aarch64-linux vous permet de construire des paquets dans un environnement 32-bit complet.

Remarque : La possibilité de construire pour un système armhf-linux est activé sans condition sur les machines aarch64-linux, bien que certaines puces aarch64 n’en soient pas capables, comme les ThunderX.

De même, lorsque l’émulation transparente avec QEMU et binfnmt_misc est activée (voir qemu-binfmt-service-type), vous pouvez construire pour n’importe quel système pour lequel un gestionnaire QEMU binfmt_misc est installé.

Les constructions pour un autre système que celui de la machine que vous utilisez peuvent aussi être déchargées à une machine distante de la bonne architecture. Voir Utiliser le dispositif de déchargement, pour plus d’information sur le déchargement.

--target=triplet ¶

Effectuer une compilation croisée pour triplet qui doit être un triplet GNU valide, comme "aarch64-linux-gnu" (voir GNU configuration triplets dans Autoconf).

--list-systems

Liste tous les systèmes pris en charge, qui peuvent être passés en argument à --system.

--list-targets

Liste toutes les cibles prises en charge, qui peuvent être passées en argument à --target.

--check ¶

Reconstruit les package-or-derivation, qui sont déjà disponibles dans le dépôt et lève une erreur si les résultats des constructions ne sont pas identiques bit-à-bit.

Ce mécanisme vous permet de vérifier si les substituts précédemment installés sont authentiques (voir Substituts) ou si le résultat de la construction d’un paquet est déterministe. Voir Invoquer guix challenge pour plus d’informations et pour les outils.

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

--repair ¶

Essaye de réparer les éléments du dépôt spécifiés, s’ils sont corrompus, en les téléchargeant ou en les construisant à nouveau.

Cette opération n’est pas atomique et donc restreinte à l’utilisateur root.

--derivations

-d

Renvoie les chemins de dérivation, et non les chemins de sortie, des paquets donnés.

--root=fichier ¶

-r fichier

Fait de fichier un lien symbolique vers le résultat, et l’enregistre en tant que racine du ramasse-miettes.

En conséquence, les résultats de cette invocation de guix build sont protégés du ramasse-miettes jusqu’à ce que fichier soit supprimé. Lorsque cette option est omise, les constructions sont susceptibles d’être glanées.

--log-file ¶

Renvoie les noms des journaux de construction ou les URL des package-or-derivation donnés ou lève une erreur si les journaux de construction sont absents.

Cela fonctionne indépendamment de la manière dont les paquets ou les dérivations sont spécifiées. Par exemple, les invocations suivantes sont équivalentes :

guix build --log-file $(guix build -d guile)
guix build --log-file $(guix build guile)
guix build --log-file guile
guix build --log-file -e '(@ (gnu packages guile) guile-2.0)'

Si un journal n’est pas disponible localement, à moins que --no-substitutes ne soit passé, la commande cherche un journal correspondant sur l’un des serveurs de substituts (tels que spécifiés avec --substitute-urls).

Donc par exemple, imaginons que vous souhaitiez voir le journal de construction de GDB sur aarch64, mais que vous n’avez qu’une machine x86_64 :

$ guix build --log-file gdb -s aarch64-linux
https://ci.guix.gnu.org/log/…-gdb-7.10

Vous pouvez accéder librement à une vaste bibliothèque de journaux de construction !