Next: La mónada del almacén, Previous: El almacén, Up: Interfaz programática [Contents][Index]
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:
x86_64-linux.
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 (see 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
(see 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:
[#: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 (see Uso de la facilidad de delegación de trabajo). 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 (see 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, see 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.
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 => …>
Next: La mónada del almacén, Previous: El almacén, Up: Interfaz programática [Contents][Index]