Siguiente: , Anterior: , Subir: Interfaz programática   [Índice general][Índice]


8.8 Derivaciones

Las acciones de construcción a bajo nivel y el entorno en el que se realizan se representan mediante derivaciones. Una derivación contiene las siguientes piezas de información:

Las derivaciones permiten a los clientes del daemon comunicar acciones de construcción al almacén. Existen en dos formas: como una representación en memoria, tanto en el lado del cliente como el del daemon, y como archivos en el almacén cuyo nombre termina en .drv—estos archivos se conocen como rutas de derivación. Las rutas de derivación se pueden proporcionar al procedimiento build-derivations para que realice las acciones de construcción prescritas (véase El almacén).

Operaciones como la descarga de archivos y las instantáneas de un control de versiones para las cuales el hash del contenido esperado se conoce previamente se modelan como derivaciones de salida fija. Al contrario que las derivaciones normales, las salidas de una derivación de salida fija son independientes de sus entradas—por ejemplo, la descarga del código fuente produce el mismo resultado independientemente del método de descarga y las herramientas usadas.

Las derivaciones de salida—es decir, los resultados de construcción—tienen un conjunto de referencias, del que informa la RPC references o la orden guix gc --references (véase Invocación de guix gc). Las referencias son el conjunto de dependencias en tiempo de ejecución de los resultados de construcción. Las referencias son un subconjunto de las entradas de la derivación; el daemon de construcción calcula este subconjunto de forma automática mediante el procesado de todos los archivos en las salidas.

El módulo (guix derivations) proporciona una representación de derivaciones como objetos Scheme, junto a procedimientos para crear y manipular de otras formas derivaciones. La primitiva de más bajo nivel para crear una derivación es el procedimiento derivation:

Procedimiento Scheme: derivation almacén nombre constructor args [#:outputs '("out")] [#:hash #f] [#:hash-algo #f] [#:recursive? #f] [#:inputs '()] [#:env-vars '()] [#:system (%current-system)] [#:references-graphs #f] [#:allowed-references #f] [#:disallowed-references #f] [#:leaked-env-vars #f] [#:local-build? #f] [#:substitutable? #t] [#:properties '()]

Construye una derivación con los parámetros proporcionados, y devuelve el objeto <derivation> resultante.

Cuando se proporcionan hash y hash-algo, una derivación de salida fija se crea—es decir, una cuyo resultado se conoce de antemano, como la descarga de un archivo. Si, además, recursive? es verdadero, entonces la salida fijada puede ser un archivo ejecutable o un directorio y hash debe ser el hash de un archivador que contenga esta salida.

Cuando references-graphs es verdadero, debe ser una lista de pares de nombre de archivo/ruta del almacén. En ese caso, el grafo de referencias de cada ruta del almacén se exporta en el entorno de construcción del archivo correspondiente, en un formato de texto simple.

Cuando allowed-references es verdadero, debe ser una lista de elementos del almacén o salidas a las que puede hacer referencia la salida de la derivación. Del mismo modo, disallowed-references, en caso de ser verdadero, debe ser una lista de cosas a las que las salidas no pueden hacer referencia.

Cuando leaked-env-vars es verdadero, debe ser una lista de cadenas que denoten variables de entorno que se permite “escapar” del entorno del daemon al entorno de construcción. Esto es únicamente aplicable a derivaciones de salida fija—es decir, cuando hash es verdadero. El uso principal es permitir que variables como http_proxy sean pasadas a las derivaciones que descargan archivos.

Cuando local-build? es verdadero, declara que la derivación no es una buena candidata para delegación y debe ser construida localmente (véase Configuración de delegación del daemon). Este es el caso para pequeñas derivaciones donde los costes de transferencia de datos sobrepasarían los beneficios.

Cuando substitutable? es falso, declara que las sustituciones de la salida de la derivación no deben usarse (véase Sustituciones). Esto es útil, por ejemplo, cuando se construyen paquetes que capturan detalles sobre el conjunto de instrucciones de la CPU anfitriona.

properties debe ser una lista asociada que describe “propiedades” de la derivación. Debe mantenerse tal cual, sin interpretar, en la derivación.

Esto es un ejemplo con un guión de shell como constructor, asumiendo que almacén es una conexión abierta al daemon, bash apunta al ejecutable Bash en el almacén:

(use-modules (guix utils)
             (guix store)
             (guix derivations))

(let ((constructor   ; añade el guión de Bash al almacén
        (add-text-to-store store "mi-constructor.sh"
                           "echo hola mundo > $out\n" '())))
  (derivation almacen "foo"
              bash `("-e" ,builder)
              #:inputs `((,bash) (,constructor))
              #:env-vars '(("HOME" . "/sindirectorio"))))
 #<derivation /gnu/store/…-foo.drv => /gnu/store/…-foo>

Como puede suponerse, el uso directo de esta primitiva es algo enrevesado. Una mejor aproximación es escribir guiones de construcción en Scheme, ¡por supuesto! La mejor forma de hacerlo es escribir el código de construcción como una “expresión-G”, y pasarla a gexp->derivation. Para más información, véase Expresiones-G.

En otros tiempos, gexp->derivation no existía y la creación de derivaciones con código de construcción escrito en Scheme se conseguía con build-expression->derivation, documentada más adelante. Este procedimiento está ahora obsoleto en favor del procedimiento gexp->derivation mucho más conveniente.

Procedimiento Scheme: build-expression->derivation almacén nombre 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]

Devuelve una derivación que ejecuta la expresión Scheme exp como un constructor para la derivación nombre. inputs debe ser una lista de tuplas (nombre ruta-drv sub-drv); cuando sub-drv se omite, se asume "out". modules es una lista de nombres de módulos Guile de la ruta actual de búsqueda a copiar en el almacén, compilados, y poner a disposición en la ruta de carga durante la ejecución de exp—por ejemplo, ((guix build utils) (guix build gnu-build-system)).

exp se evalúa en un entorno donde %outputs está asociada a una lista de pares salida/ruta, y donde %build-inputs está asociada a una lista de pares cadena/ruta-de-salida que provienen de inputs. De manera opcional, env-vars es una lista de pares de cadenas que especifican el nombre y el valor de las variables de entorno visibles al constructor. El constructor termina pasando el resultado de exp a exit; por tanto, cuando exp devuelve #f, la construcción se considera fallida.

exp se construye usando guile-for-build (una derivación). Cuando guile-for-build se omite o es #f, el valor del fluido %guile-for-build se usa en su lugar.

Véase el procedimiento derivation para el significado de references-graphs, allowed-references, disallowed-references, local-build? y substitutable?.

Aquí está un ejemplo de derivación de salida única que crea un directorio que contiene un archivo:

(let ((constructor '(let ((salida (assoc-ref %outputs "out")))
                      (mkdir salida)    ; crea /gnu/store/…-goo
                      (call-with-output-file (string-append salida "/prueba")
                        (lambda (p)
                          (display '(hola guix) p))))))
  (build-expression->derivation almacen "goo" constructor))

 #<derivation /gnu/store/…-goo.drv => …>

Siguiente: , Anterior: , Subir: Interfaz programática   [Índice general][Índice]