Siguiente: , Anterior: , Subir: Invocación de guix build   [Índice general][Índice]


9.1.3 Opciones de construcción adicionales

Las opciones de línea de ordenes presentadas a continuación son específicas de guix build.

--quiet
-q

Construye silenciosamente, sin mostrar el registro de construcción; es equivalente a --verbosity=0. Al finalizar, el registro de construcción se mantiene en /var (o similar) y puede recuperarse siempre mediante el uso de la opción --log-file.

--file=archivo
-f archivo

Construye el paquete, derivación u otro objeto tipo-archivo al que evalúa el código en archivo (véase objetos “tipo-archivo”).

Como un ejemplo, archivo puede contener una definición como esta (véase Definición de paquetes):

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

El archivo también puede contener una representación en JSON de una o más definiciones de paquete. Ejecutar guix build -f en hello.json con el siguiente contenido resultaría en la construcción de los paquetes myhello y 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=manifiesto
-m manifiesto

Construye todos los paquetes listados en el manifiesto proporcionado (véase --manifest).

--expression=expr
-e expr

Construye el paquete o derivación a la que evalúa expr.

Por ejemplo, expr puede ser (@ (gnu packages guile) guile-1.8), que designa sin ambigüedad a esta variante específica de la versión 1.8 de Guile.

De manera alternativa, expr puede ser una expresión-G, en cuyo caso se usa como un programa de construcción pasado a gexp->derivation (véase Expresiones-G).

Por último, expr puede hacer referencia a un procedimiento mónadico sin parámetros (véase La mónada del almacén). El procedimiento debe devolver una derivación como un valor monádico, el cual después se pasa a través de run-with-store.

--source
-S

Construye las derivaciones de las fuentes de los paquetes, en vez de los paquetes mismos.

Por ejemplo, guix build -S gcc devuelve algo como /gnu/store/…-gcc-4.7.2.tar.bz2, el cual es el archivador tar de fuentes de GCC.

El archivador tar devuelto es el resultado de aplicar cualquier parche y fragmento de código en el origen (campo origin) del paquete (véase Definición de paquetes).

As with other derivations, the result of building a source derivation can be verified using the --check option (véase build-check). This is useful to validate that a (potentially already built or substituted, thus cached) package source matches against its declared hash.

Tenga en cuenta que guix build -S compila las fuentes únicamente de los paquetes especificados. Esto no incluye las dependencias enlazadas estáticamente y por sí mismas son insuficientes para reproducir los paquetes.

--sources

Obtiene y devuelve las fuentes de paquete-o-derivación y todas sus dependencias, de manera recursiva. Esto es útil para obtener una copia local de todo el código fuente necesario para construir los paquetes, le permite construirlos llegado el momento sin acceso a la red. Es una extensión de la opción --source y puede aceptar uno de los siguientes valores opcionales como parámetro:

package

Este valor hace que la opción --sources se comporte de la misma manera que la opción --source.

all

Construye las derivaciones de las fuentes de todos los paquetes, incluyendo cualquier fuente que pueda enumerarse como entrada (campo inputs). Este es el valor predeterminado.

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

Construye las derivaciones de fuentes de todos los paquetes, así como todas las entradas transitivas de los paquetes. Esto puede usarse, por ejemplo, para obtener las fuentes de paquetes para una construcción posterior sin conexión a la red.

$ 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=sistema
-s sistema

Intenta la construcción para sistema—por ejemplo, i686-linux—en vez del tipo de sistema de la máquina de construcción. La orden guix build le permite repetir esta opción varias veces, en cuyo caso construye para todos los sistemas especificados; otras ordenes ignoran opciones -s extrañas.

Nota: La opción --system es para compilación nativa y no debe confundirse con la compilación cruzada. Véase --target más adelante para información sobre compilación cruzada.

Un ejemplo de uso de esta opción es en sistemas basados en Linux, que pueden emular diferentes personalidades. Por ejemplo, proporcionar la opción --system=i686-linux en un sistema x86_64-linux, o la opción --system=armhf-linux en un sistema aarch64-linux, le permite construir paquetes en un entorno de 32-bits completo.

Nota: La construcción para un sistema armhf-linux está disponible de manera incondicional en máquinas aarch64-linux, aunque determinadas familias de procesadores aarch64 no lo permitan, notablemente el ThunderX.

De manera similar, cuando la emulación transparente con QEMU y binfmt_misc está activada (véase qemu-binfmt-service-type), puede construir para cualquier sistema para el que un manejador QEMU de binfmt_misc esté instalado.

Las construcciones para un sistema distinto al de la máquina que usa se pueden delegar también a una máquina remota de la arquitectura correcta. Véase Configuración de delegación del daemon, para más información sobre delegación.

--target=tripleta

Compilación cruzada para la tripleta, que debe ser una tripleta GNU válida, cómo "aarch64-linux-gnu" (véase GNU configuration triplets en Autoconf).

--check

Reconstruye paquete-o-derivación, que ya está disponible en el almacén, y emite un error si los resultados de la construcción no son idénticos bit-a-bit.

Este mecanismo le permite comprobar si sustituciones previamente instaladas son genuinas (véase Sustituciones), o si el resultado de la construcción de un paquete es determinista. Véase Invocación de guix challenge, para más información de referencia y herramientas.

Cuando se usa conjuntamente con --keep-failed, la salida que difiere se mantiene en el almacén, bajo /gnu/store/…-check. Esto hace fácil buscar diferencias entre los dos resultados.

--repair

Intenta reparar los elementos del almacén especificados, si están corruptos, volviendo a descargarlos o mediante su reconstrucción.

Esta operación no es atómica y por lo tanto está restringida a root.

--derivations
-d

Devuelve las rutas de derivación, no las rutas de salida, de los paquetes proporcionados.

--root=archivo
-r archivo

Hace que archivo sea un enlace simbólico al resultado, y lo registra como una raíz del recolector de basura.

Consecuentemente, los resultados de esta invocación de guix build se protegen de la recolección de basura hasta que archivo se elimine. Cuando se omite esa opción, los resultados son candidatos a la recolección de basura en cuanto la construcción se haya completado. Véase Invocación de guix gc, para más sobre las raíces del recolector de basura.

--log-file

Devuelve los nombres de archivos o URL de los log de construcción para el paquete-o-derivación proporcionado, o emite un error si no se encuentran los log de construcción.

Esto funciona independientemente de cómo se especificasen los paquetes o derivaciones. Por ejemplo, las siguientes invocaciones son equivalentes:

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 no está disponible un registro local, y a menos que se proporcione --no-substitutes, la orden busca el registro correspondiente en uno de los servidores de sustituciones (como se especificaron con --substitute-urls).

Por lo que dado el caso, imaginese que desea ver el log de construcción de GDB en MIPS, pero realmente está en una máquina x86_64:

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

¡Puede acceder libremente a una biblioteca inmensa de log de construcción!


Siguiente: , Anterior: , Subir: Invocación de guix build   [Índice general][Índice]