2013-01-06 00:47:50 +01:00
|
|
|
|
;;; GNU Guix --- Functional package management for GNU
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
|
2012-04-19 23:09:55 +02:00
|
|
|
|
;;;
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; This file is part of GNU Guix.
|
2012-04-19 23:09:55 +02:00
|
|
|
|
;;;
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; GNU Guix is free software; you can redistribute it and/or modify it
|
2012-04-19 23:09:55 +02:00
|
|
|
|
;;; under the terms of the GNU General Public License as published by
|
|
|
|
|
;;; the Free Software Foundation; either version 3 of the License, or (at
|
|
|
|
|
;;; your option) any later version.
|
|
|
|
|
;;;
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; GNU Guix is distributed in the hope that it will be useful, but
|
2012-04-19 23:09:55 +02:00
|
|
|
|
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
;;; GNU General Public License for more details.
|
|
|
|
|
;;;
|
|
|
|
|
;;; You should have received a copy of the GNU General Public License
|
2013-01-06 00:47:50 +01:00
|
|
|
|
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
|
2012-04-19 23:09:55 +02:00
|
|
|
|
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(unsetenv "http_proxy")
|
|
|
|
|
|
2012-04-19 23:09:55 +02:00
|
|
|
|
(define-module (test-derivations)
|
|
|
|
|
#:use-module (guix derivations)
|
2016-03-06 21:53:28 +01:00
|
|
|
|
#:use-module (guix grafts)
|
2012-06-01 23:29:55 +02:00
|
|
|
|
#:use-module (guix store)
|
2012-06-07 23:15:00 +02:00
|
|
|
|
#:use-module (guix utils)
|
Switch to Guile-Gcrypt.
This removes (guix hash) and (guix pk-crypto), which now live as part of
Guile-Gcrypt (version 0.1.0.)
* guix/gcrypt.scm, guix/hash.scm, guix/pk-crypto.scm,
tests/hash.scm, tests/pk-crypto.scm: Remove.
* configure.ac: Test for Guile-Gcrypt. Remove LIBGCRYPT and
LIBGCRYPT_LIBDIR assignments.
* m4/guix.m4 (GUIX_ASSERT_LIBGCRYPT_USABLE): Remove.
* README: Add Guile-Gcrypt to the dependencies; move libgcrypt as
"required unless --disable-daemon".
* doc/guix.texi (Requirements): Likewise.
* gnu/packages/bash.scm, guix/derivations.scm, guix/docker.scm,
guix/git.scm, guix/http-client.scm, guix/import/cpan.scm,
guix/import/cran.scm, guix/import/crate.scm, guix/import/elpa.scm,
guix/import/gnu.scm, guix/import/hackage.scm,
guix/import/texlive.scm, guix/import/utils.scm, guix/nar.scm,
guix/pki.scm, guix/scripts/archive.scm,
guix/scripts/authenticate.scm, guix/scripts/download.scm,
guix/scripts/hash.scm, guix/scripts/pack.scm,
guix/scripts/publish.scm, guix/scripts/refresh.scm,
guix/scripts/substitute.scm, guix/store.scm,
guix/store/deduplication.scm, guix/tests.scm, tests/base32.scm,
tests/builders.scm, tests/challenge.scm, tests/cpan.scm,
tests/crate.scm, tests/derivations.scm, tests/gem.scm,
tests/nar.scm, tests/opam.scm, tests/pki.scm,
tests/publish.scm, tests/pypi.scm, tests/store-deduplication.scm,
tests/store.scm, tests/substitute.scm: Adjust imports.
* gnu/system/vm.scm: Likewise.
(guile-sqlite3&co): Rename to...
(gcrypt-sqlite3&co): ... this. Add GUILE-GCRYPT.
(expression->derivation-in-linux-vm)[config]: Remove.
(iso9660-image)[config]: Remove.
(qemu-image)[config]: Remove.
(system-docker-image)[config]: Remove.
* guix/scripts/pack.scm: Adjust imports.
(guile-sqlite3&co): Rename to...
(gcrypt-sqlite3&co): ... this. Add GUILE-GCRYPT.
(self-contained-tarball)[build]: Call 'make-config.scm' without
#:libgcrypt argument.
(squashfs-image)[libgcrypt]: Remove.
[build]: Call 'make-config.scm' without #:libgcrypt.
(docker-image)[config, json]: Remove.
[build]: Add GUILE-GCRYPT to the extensions Remove (guix config) from
the imported modules.
* guix/self.scm (specification->package): Remove "libgcrypt", add
"guile-gcrypt".
(compiled-guix): Remove #:libgcrypt.
[guile-gcrypt]: New variable.
[dependencies]: Add it.
[*core-modules*]: Remove #:libgcrypt from 'make-config.scm' call.
Add #:extensions.
[*config*]: Remove #:libgcrypt from 'make-config.scm' call.
(%dependency-variables): Remove %libgcrypt.
(make-config.scm): Remove #:libgcrypt.
* build-aux/build-self.scm (guile-gcrypt): New variable.
(make-config.scm): Remove #:libgcrypt.
(build-program)[fake-gcrypt-hash]: New variable.
Add (gcrypt hash) to the imported modules. Adjust load path
assignments.
* gnu/packages/package-management.scm (guix)[propagated-inputs]: Add
GUILE-GCRYPT.
[arguments]: In 'wrap-program' phase, add GUILE-GCRYPT to the search
path.
2018-08-31 17:07:07 +02:00
|
|
|
|
#:use-module (gcrypt hash)
|
Move base32 code to (guix base32).
* guix/utils.scm (bytevector-quintet-ref, bytevector-quintet-ref-right,
bytevector-quintet-length, bytevector-quintet-fold,
bytevector-quintet-fold-right, make-bytevector->base32-string,
%nix-base32-chars, %rfc4648-base32-chars, bytevector->base32-string,
bytevector->nix-base32-string, bytevector-quintet-set!,
bytevector-quintet-set-right!, base32-string-unfold,
base32-string-unfold-right, make-base32-string->bytevector,
base32-string->bytevector, nix-base32-string->bytevector): Move to...
* guix/base32.scm: ... here. New file.
* tests/utils.scm (%nix-hash, "bytevector->base32-string",
"base32-string->bytevector", "nix-base32-string->bytevector", "sha256
& bytevector->base32-string"): Move to...
* tests/base32.scm: ... here. New file
* guix-download.in, guix/derivations.scm, guix/packages.scm,
guix/snix.scm, tests/builders.scm, tests/derivations.scm: Adjust
accordingly.
* guix.scm (%public-modules): Add `base32'.
2012-11-11 22:33:28 +01:00
|
|
|
|
#:use-module (guix base32)
|
2014-08-23 19:18:01 +02:00
|
|
|
|
#:use-module (guix tests)
|
2015-07-20 04:30:16 +02:00
|
|
|
|
#:use-module (guix tests http)
|
2014-02-21 23:03:19 +01:00
|
|
|
|
#:use-module ((guix packages) #:select (package-derivation base32))
|
|
|
|
|
#:use-module ((guix build utils) #:select (executable-file?))
|
2013-01-18 01:06:24 +01:00
|
|
|
|
#:use-module (gnu packages bootstrap)
|
2013-11-13 00:25:57 +01:00
|
|
|
|
#:use-module ((gnu packages guile) #:select (guile-1.8))
|
2012-06-10 22:43:02 +02:00
|
|
|
|
#:use-module (srfi srfi-1)
|
2012-06-05 00:04:07 +02:00
|
|
|
|
#:use-module (srfi srfi-11)
|
2012-04-19 23:09:55 +02:00
|
|
|
|
#:use-module (srfi srfi-26)
|
2012-06-11 23:12:55 +02:00
|
|
|
|
#:use-module (srfi srfi-34)
|
2012-04-19 23:09:55 +02:00
|
|
|
|
#:use-module (srfi srfi-64)
|
2012-06-05 00:04:07 +02:00
|
|
|
|
#:use-module (rnrs io ports)
|
2012-06-09 18:49:19 +02:00
|
|
|
|
#:use-module (rnrs bytevectors)
|
2013-04-17 00:06:59 +02:00
|
|
|
|
#:use-module (web uri)
|
2012-06-10 22:43:02 +02:00
|
|
|
|
#:use-module (ice-9 rdelim)
|
2012-06-16 16:46:29 +02:00
|
|
|
|
#:use-module (ice-9 regex)
|
2012-06-11 23:12:55 +02:00
|
|
|
|
#:use-module (ice-9 ftw)
|
|
|
|
|
#:use-module (ice-9 match))
|
2012-04-19 23:09:55 +02:00
|
|
|
|
|
2012-06-01 23:29:55 +02:00
|
|
|
|
(define %store
|
2014-08-23 19:18:01 +02:00
|
|
|
|
(open-connection-for-tests))
|
2012-10-25 18:03:48 +02:00
|
|
|
|
|
2016-03-06 21:53:28 +01:00
|
|
|
|
;; Globally disable grafts because they can trigger early builds.
|
|
|
|
|
(%graft? #f)
|
|
|
|
|
|
2013-08-26 22:12:46 +02:00
|
|
|
|
(define (bootstrap-binary name)
|
|
|
|
|
(let ((bin (search-bootstrap-binary name (%current-system))))
|
2013-01-02 01:04:37 +01:00
|
|
|
|
(and %store
|
2013-08-26 22:12:46 +02:00
|
|
|
|
(add-to-store %store name #t "sha256" bin))))
|
|
|
|
|
|
|
|
|
|
(define %bash
|
|
|
|
|
(bootstrap-binary "bash"))
|
|
|
|
|
(define %mkdir
|
|
|
|
|
(bootstrap-binary "mkdir"))
|
2013-01-02 01:04:37 +01:00
|
|
|
|
|
2013-08-26 22:12:46 +02:00
|
|
|
|
(define* (directory-contents dir #:optional (slurp get-bytevector-all))
|
2012-06-10 22:43:02 +02:00
|
|
|
|
"Return an alist representing the contents of DIR."
|
|
|
|
|
(define prefix-len (string-length dir))
|
|
|
|
|
(sort (file-system-fold (const #t) ; enter?
|
|
|
|
|
(lambda (path stat result) ; leaf
|
|
|
|
|
(alist-cons (string-drop path prefix-len)
|
2013-08-26 22:12:46 +02:00
|
|
|
|
(call-with-input-file path slurp)
|
2012-06-10 22:43:02 +02:00
|
|
|
|
result))
|
|
|
|
|
(lambda (path stat result) result) ; down
|
|
|
|
|
(lambda (path stat result) result) ; up
|
|
|
|
|
(lambda (path stat result) result) ; skip
|
|
|
|
|
(lambda (path stat errno result) result) ; error
|
|
|
|
|
'()
|
|
|
|
|
dir)
|
|
|
|
|
(lambda (e1 e2)
|
|
|
|
|
(string<? (car e1) (car e2)))))
|
|
|
|
|
|
2015-07-20 04:30:16 +02:00
|
|
|
|
;; Avoid collisions with other tests.
|
|
|
|
|
(%http-server-port 10500)
|
|
|
|
|
|
2016-03-06 21:53:28 +01:00
|
|
|
|
|
2012-04-19 23:09:55 +02:00
|
|
|
|
(test-begin "derivations")
|
|
|
|
|
|
|
|
|
|
(test-assert "parse & export"
|
2012-06-05 11:18:20 +02:00
|
|
|
|
(let* ((f (search-path %load-path "tests/test.drv"))
|
|
|
|
|
(b1 (call-with-input-file f get-bytevector-all))
|
2019-06-23 11:28:29 +02:00
|
|
|
|
(d1 (read-derivation (open-bytevector-input-port b1)
|
|
|
|
|
identity))
|
2012-04-19 23:09:55 +02:00
|
|
|
|
(b2 (call-with-bytevector-output-port (cut write-derivation d1 <>)))
|
2019-06-23 11:28:29 +02:00
|
|
|
|
(d2 (read-derivation (open-bytevector-input-port b2)
|
|
|
|
|
identity)))
|
2012-04-19 23:09:55 +02:00
|
|
|
|
(and (equal? b1 b2)
|
|
|
|
|
(equal? d1 d2))))
|
|
|
|
|
|
2013-08-26 22:12:46 +02:00
|
|
|
|
(test-skip (if %store 0 12))
|
2012-06-10 22:43:02 +02:00
|
|
|
|
|
2012-06-12 00:19:04 +02:00
|
|
|
|
(test-assert "add-to-store, flat"
|
2018-01-30 21:33:34 +01:00
|
|
|
|
;; Use 'readlink*' in case spec.scm is a symlink, as is the case when Guile
|
|
|
|
|
;; was installed with Stow.
|
|
|
|
|
(let* ((file (readlink*
|
|
|
|
|
(search-path %load-path "language/tree-il/spec.scm")))
|
2013-01-30 16:30:49 +01:00
|
|
|
|
(drv (add-to-store %store "flat-test" #f "sha256" file)))
|
2012-06-12 00:19:04 +02:00
|
|
|
|
(and (eq? 'regular (stat:type (stat drv)))
|
2012-07-01 00:21:16 +02:00
|
|
|
|
(valid-path? %store drv)
|
2012-06-12 00:19:04 +02:00
|
|
|
|
(equal? (call-with-input-file file get-bytevector-all)
|
|
|
|
|
(call-with-input-file drv get-bytevector-all)))))
|
|
|
|
|
|
2012-06-10 22:43:02 +02:00
|
|
|
|
(test-assert "add-to-store, recursive"
|
2018-01-30 21:33:34 +01:00
|
|
|
|
(let* ((dir (dirname
|
|
|
|
|
(readlink* (search-path %load-path
|
|
|
|
|
"language/tree-il/spec.scm"))))
|
2013-01-30 16:30:49 +01:00
|
|
|
|
(drv (add-to-store %store "dir-tree-test" #t "sha256" dir)))
|
2012-06-10 22:43:02 +02:00
|
|
|
|
(and (eq? 'directory (stat:type (stat drv)))
|
2012-07-01 00:21:16 +02:00
|
|
|
|
(valid-path? %store drv)
|
2012-06-10 22:43:02 +02:00
|
|
|
|
(equal? (directory-contents dir)
|
|
|
|
|
(directory-contents drv)))))
|
2012-06-01 23:29:55 +02:00
|
|
|
|
|
|
|
|
|
(test-assert "derivation with no inputs"
|
2012-07-01 00:21:16 +02:00
|
|
|
|
(let* ((builder (add-text-to-store %store "my-builder.sh"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
"echo hello, world\n"
|
2012-07-01 00:21:16 +02:00
|
|
|
|
'()))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv (derivation %store "foo"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `("-e" ,builder)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
#:env-vars '(("HOME" . "/homeless")))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(and (store-path? (derivation-file-name drv))
|
|
|
|
|
(valid-path? %store (derivation-file-name drv)))))
|
2012-06-01 23:29:55 +02:00
|
|
|
|
|
2012-06-05 00:04:07 +02:00
|
|
|
|
(test-assert "build derivation with 1 source"
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let* ((builder (add-text-to-store %store "my-builder.sh"
|
|
|
|
|
"echo hello, world > \"$out\"\n"
|
|
|
|
|
'()))
|
|
|
|
|
(drv (derivation %store "foo"
|
|
|
|
|
%bash `(,builder)
|
|
|
|
|
#:env-vars '(("HOME" . "/homeless")
|
|
|
|
|
("zzz" . "Z!")
|
|
|
|
|
("AAA" . "A!"))
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash) (,builder))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded?
|
|
|
|
|
(build-derivations %store (list drv))))
|
2012-06-05 00:04:07 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((path (derivation->output-path drv)))
|
2012-07-01 00:21:16 +02:00
|
|
|
|
(and (valid-path? %store path)
|
|
|
|
|
(string=? (call-with-input-file path read-line)
|
|
|
|
|
"hello, world"))))))
|
2012-06-05 00:04:07 +02:00
|
|
|
|
|
2012-12-04 23:46:50 +01:00
|
|
|
|
(test-assert "derivation with local file as input"
|
|
|
|
|
(let* ((builder (add-text-to-store
|
|
|
|
|
%store "my-builder.sh"
|
2013-02-03 23:23:29 +01:00
|
|
|
|
"(while read line ; do echo \"$line\" ; done) < $in > $out"
|
2012-12-04 23:46:50 +01:00
|
|
|
|
'()))
|
|
|
|
|
(input (search-path %load-path "ice-9/boot-9.scm"))
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(input* (add-to-store %store (basename input)
|
|
|
|
|
#t "sha256" input))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv (derivation %store "derivation-with-input-file"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
|
|
|
|
|
;; Cheat to pass the actual file name to the
|
|
|
|
|
;; builder.
|
|
|
|
|
#:env-vars `(("in" . ,input*))
|
|
|
|
|
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash)
|
|
|
|
|
(,builder)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(,input))))) ; ← local file name
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(and (build-derivations %store (list drv))
|
2013-02-03 23:23:29 +01:00
|
|
|
|
;; Note: we can't compare the files because the above trick alters
|
|
|
|
|
;; the contents.
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(valid-path? %store (derivation->output-path drv)))))
|
2012-12-04 23:46:50 +01:00
|
|
|
|
|
2016-01-19 21:38:44 +01:00
|
|
|
|
(test-assert "derivation fails but keep going"
|
|
|
|
|
;; In keep-going mode, 'build-derivations' should fail because of D1, but it
|
|
|
|
|
;; must return only after D2 has succeeded.
|
|
|
|
|
(with-store store
|
|
|
|
|
(let* ((d1 (derivation %store "fails"
|
|
|
|
|
%bash `("-c" "false")
|
|
|
|
|
#:inputs `((,%bash))))
|
|
|
|
|
(d2 (build-expression->derivation %store "sleep-then-succeed"
|
|
|
|
|
`(begin
|
|
|
|
|
,(random-text)
|
|
|
|
|
;; XXX: Hopefully that's long
|
|
|
|
|
;; enough that D1 has already
|
|
|
|
|
;; failed.
|
|
|
|
|
(sleep 2)
|
|
|
|
|
(mkdir %output)))))
|
|
|
|
|
(set-build-options %store
|
|
|
|
|
#:use-substitutes? #f
|
|
|
|
|
#:keep-going? #t)
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
|
|
|
|
(and (= 100 (store-protocol-error-status c))
|
|
|
|
|
(string-contains (store-protocol-error-message c)
|
2016-01-19 21:38:44 +01:00
|
|
|
|
(derivation-file-name d1))
|
|
|
|
|
(not (valid-path? %store (derivation->output-path d1)))
|
|
|
|
|
(valid-path? %store (derivation->output-path d2)))))
|
|
|
|
|
(build-derivations %store (list d1 d2))
|
|
|
|
|
#f))))
|
|
|
|
|
|
2014-08-31 14:43:38 +02:00
|
|
|
|
(test-assert "identical files are deduplicated"
|
|
|
|
|
(let* ((build1 (add-text-to-store %store "one.sh"
|
|
|
|
|
"echo hello, world > \"$out\"\n"
|
|
|
|
|
'()))
|
|
|
|
|
(build2 (add-text-to-store %store "two.sh"
|
|
|
|
|
"# Hey!\necho hello, world > \"$out\"\n"
|
|
|
|
|
'()))
|
|
|
|
|
(drv1 (derivation %store "foo"
|
|
|
|
|
%bash `(,build1)
|
|
|
|
|
#:inputs `((,%bash) (,build1))))
|
|
|
|
|
(drv2 (derivation %store "bar"
|
|
|
|
|
%bash `(,build2)
|
|
|
|
|
#:inputs `((,%bash) (,build2)))))
|
|
|
|
|
(and (build-derivations %store (list drv1 drv2))
|
|
|
|
|
(let ((file1 (derivation->output-path drv1))
|
|
|
|
|
(file2 (derivation->output-path drv2)))
|
|
|
|
|
(and (valid-path? %store file1) (valid-path? %store file2)
|
|
|
|
|
(string=? (call-with-input-file file1 get-string-all)
|
|
|
|
|
"hello, world\n")
|
|
|
|
|
(= (stat:ino (lstat file1))
|
|
|
|
|
(stat:ino (lstat file2))))))))
|
|
|
|
|
|
2016-11-13 22:59:54 +01:00
|
|
|
|
(test-equal "built-in-builders"
|
|
|
|
|
'("download")
|
|
|
|
|
(built-in-builders %store))
|
|
|
|
|
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(test-assert "unknown built-in builder"
|
|
|
|
|
(let ((drv (derivation %store "ohoh" "builtin:does-not-exist" '())))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
|
|
|
|
(string-contains (store-protocol-error-message c) "failed")))
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(build-derivations %store (list drv))
|
|
|
|
|
#f)))
|
|
|
|
|
|
2017-10-12 23:19:09 +02:00
|
|
|
|
(unless (http-server-can-listen?)
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(test-skip 1))
|
|
|
|
|
(test-assert "'download' built-in builder"
|
|
|
|
|
(let ((text (random-text)))
|
|
|
|
|
(with-http-server 200 text
|
|
|
|
|
(let* ((drv (derivation %store "world"
|
|
|
|
|
"builtin:download" '()
|
|
|
|
|
#:env-vars `(("url"
|
|
|
|
|
. ,(object->string (%local-url))))
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:hash (sha256 (string->utf8 text)))))
|
|
|
|
|
(and (build-derivations %store (list drv))
|
|
|
|
|
(string=? (call-with-input-file (derivation->output-path drv)
|
|
|
|
|
get-string-all)
|
|
|
|
|
text))))))
|
|
|
|
|
|
2017-10-12 23:19:09 +02:00
|
|
|
|
(unless (http-server-can-listen?)
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(test-skip 1))
|
|
|
|
|
(test-assert "'download' built-in builder, invalid hash"
|
|
|
|
|
(with-http-server 200 "hello, world!"
|
|
|
|
|
(let* ((drv (derivation %store "world"
|
|
|
|
|
"builtin:download" '()
|
|
|
|
|
#:env-vars `(("url"
|
|
|
|
|
. ,(object->string (%local-url))))
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:hash (sha256 (random-bytevector 100))))) ;wrong
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
|
|
|
|
(string-contains (store-protocol-error-message c) "failed")))
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(build-derivations %store (list drv))
|
|
|
|
|
#f))))
|
|
|
|
|
|
2017-10-12 23:19:09 +02:00
|
|
|
|
(unless (http-server-can-listen?)
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(test-skip 1))
|
|
|
|
|
(test-assert "'download' built-in builder, not found"
|
|
|
|
|
(with-http-server 404 "not found"
|
|
|
|
|
(let* ((drv (derivation %store "will-never-be-found"
|
|
|
|
|
"builtin:download" '()
|
|
|
|
|
#:env-vars `(("url"
|
|
|
|
|
. ,(object->string (%local-url))))
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:hash (sha256 (random-bytevector 100)))))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
|
|
|
|
(string-contains (store-protocol-error-message (pk c)) "failed")))
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(build-derivations %store (list drv))
|
|
|
|
|
#f))))
|
|
|
|
|
|
|
|
|
|
(test-assert "'download' built-in builder, not fixed-output"
|
|
|
|
|
(let* ((source (add-text-to-store %store "hello" "hi!"))
|
|
|
|
|
(url (string-append "file://" source))
|
|
|
|
|
(drv (derivation %store "world"
|
|
|
|
|
"builtin:download" '()
|
|
|
|
|
#:env-vars `(("url" . ,(object->string url))))))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
|
|
|
|
(string-contains (store-protocol-error-message c) "failed")))
|
2015-07-20 04:30:16 +02:00
|
|
|
|
(build-derivations %store (list drv))
|
|
|
|
|
#f)))
|
|
|
|
|
|
2017-10-12 23:19:09 +02:00
|
|
|
|
(unless (http-server-can-listen?)
|
2017-01-11 17:06:31 +01:00
|
|
|
|
(test-skip 1))
|
|
|
|
|
(test-assert "'download' built-in builder, check mode"
|
|
|
|
|
;; Make sure rebuilding the 'builtin:download' derivation in check mode
|
|
|
|
|
;; works. See <http://bugs.gnu.org/25089>.
|
|
|
|
|
(let* ((text (random-text))
|
|
|
|
|
(drv (derivation %store "world"
|
|
|
|
|
"builtin:download" '()
|
|
|
|
|
#:env-vars `(("url"
|
|
|
|
|
. ,(object->string (%local-url))))
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:hash (sha256 (string->utf8 text)))))
|
|
|
|
|
(and (with-http-server 200 text
|
|
|
|
|
(build-derivations %store (list drv)))
|
|
|
|
|
(with-http-server 200 text
|
|
|
|
|
(build-derivations %store (list drv)
|
|
|
|
|
(build-mode check)))
|
|
|
|
|
(string=? (call-with-input-file (derivation->output-path drv)
|
|
|
|
|
get-string-all)
|
|
|
|
|
text))))
|
|
|
|
|
|
2014-10-17 20:58:02 +02:00
|
|
|
|
(test-equal "derivation-name"
|
|
|
|
|
"foo-0.0"
|
|
|
|
|
(let ((drv (derivation %store "foo-0.0" %bash '())))
|
|
|
|
|
(derivation-name drv)))
|
|
|
|
|
|
2015-01-09 23:33:42 +01:00
|
|
|
|
(test-equal "derivation-output-names"
|
|
|
|
|
'(("out") ("bar" "chbouib"))
|
|
|
|
|
(let ((drv1 (derivation %store "foo-0.0" %bash '()))
|
|
|
|
|
(drv2 (derivation %store "foo-0.0" %bash '()
|
|
|
|
|
#:outputs '("bar" "chbouib"))))
|
|
|
|
|
(list (derivation-output-names drv1)
|
|
|
|
|
(derivation-output-names drv2))))
|
|
|
|
|
|
2014-10-28 18:05:17 +01:00
|
|
|
|
(test-assert "offloadable-derivation?"
|
|
|
|
|
(and (offloadable-derivation? (derivation %store "foo" %bash '()))
|
2015-07-03 00:05:16 +02:00
|
|
|
|
(offloadable-derivation? ;see <http://bugs.gnu.org/18747>
|
|
|
|
|
(derivation %store "foo" %bash '()
|
|
|
|
|
#:substitutable? #f))
|
2014-10-28 18:05:17 +01:00
|
|
|
|
(not (offloadable-derivation?
|
|
|
|
|
(derivation %store "foo" %bash '()
|
|
|
|
|
#:local-build? #t)))))
|
|
|
|
|
|
2015-07-03 00:05:16 +02:00
|
|
|
|
(test-assert "substitutable-derivation?"
|
|
|
|
|
(and (substitutable-derivation? (derivation %store "foo" %bash '()))
|
|
|
|
|
(substitutable-derivation? ;see <http://bugs.gnu.org/18747>
|
|
|
|
|
(derivation %store "foo" %bash '()
|
2015-09-05 22:08:47 +02:00
|
|
|
|
#:local-build? #t))
|
2015-07-03 00:05:16 +02:00
|
|
|
|
(not (substitutable-derivation?
|
|
|
|
|
(derivation %store "foo" %bash '()
|
|
|
|
|
#:substitutable? #f)))))
|
|
|
|
|
|
2014-04-13 00:42:07 +02:00
|
|
|
|
(test-assert "fixed-output-derivation?"
|
|
|
|
|
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
|
|
|
|
|
"echo -n hello > $out" '()))
|
|
|
|
|
(hash (sha256 (string->utf8 "hello")))
|
|
|
|
|
(drv (derivation %store "fixed"
|
|
|
|
|
%bash `(,builder)
|
|
|
|
|
#:inputs `((,builder))
|
|
|
|
|
#:hash hash #:hash-algo 'sha256)))
|
|
|
|
|
(fixed-output-derivation? drv)))
|
|
|
|
|
|
2012-06-09 18:49:19 +02:00
|
|
|
|
(test-assert "fixed-output derivation"
|
|
|
|
|
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
|
|
|
|
|
"echo -n hello > $out" '()))
|
|
|
|
|
(hash (sha256 (string->utf8 "hello")))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv (derivation %store "fixed"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
#:inputs `((,builder)) ; optional
|
2012-06-09 18:49:19 +02:00
|
|
|
|
#:hash hash #:hash-algo 'sha256))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded? (build-derivations %store (list drv))))
|
2012-06-09 18:49:19 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((p (derivation->output-path drv)))
|
2012-10-24 17:03:45 +02:00
|
|
|
|
(and (equal? (string->utf8 "hello")
|
|
|
|
|
(call-with-input-file p get-bytevector-all))
|
|
|
|
|
(bytevector? (query-path-hash %store p)))))))
|
2012-06-09 18:49:19 +02:00
|
|
|
|
|
2012-11-08 23:55:12 +01:00
|
|
|
|
(test-assert "fixed-output derivation: output paths are equal"
|
|
|
|
|
(let* ((builder1 (add-text-to-store %store "fixed-builder1.sh"
|
|
|
|
|
"echo -n hello > $out" '()))
|
|
|
|
|
(builder2 (add-text-to-store %store "fixed-builder2.sh"
|
|
|
|
|
"echo hey; echo -n hello > $out" '()))
|
|
|
|
|
(hash (sha256 (string->utf8 "hello")))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv1 (derivation %store "fixed"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder1)
|
2012-11-08 23:55:12 +01:00
|
|
|
|
#:hash hash #:hash-algo 'sha256))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv2 (derivation %store "fixed"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder2)
|
2012-11-08 23:55:12 +01:00
|
|
|
|
#:hash hash #:hash-algo 'sha256))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded? (build-derivations %store (list drv1 drv2))))
|
2012-11-08 23:55:12 +01:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(equal? (derivation->output-path drv1)
|
|
|
|
|
(derivation->output-path drv2)))))
|
2012-11-08 23:55:12 +01:00
|
|
|
|
|
2014-02-21 23:03:19 +01:00
|
|
|
|
(test-assert "fixed-output derivation, recursive"
|
|
|
|
|
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
|
|
|
|
|
"echo -n hello > $out" '()))
|
|
|
|
|
(hash (sha256 (string->utf8 "hello")))
|
|
|
|
|
(drv (derivation %store "fixed-rec"
|
|
|
|
|
%bash `(,builder)
|
|
|
|
|
#:inputs `((,builder))
|
|
|
|
|
#:hash (base32 "0sg9f58l1jj88w6pdrfdpj5x9b1zrwszk84j81zvby36q9whhhqa")
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:recursive? #t))
|
|
|
|
|
(succeeded? (build-derivations %store (list drv))))
|
|
|
|
|
(and succeeded?
|
|
|
|
|
(let ((p (derivation->output-path drv)))
|
|
|
|
|
(and (equal? (string->utf8 "hello")
|
|
|
|
|
(call-with-input-file p get-bytevector-all))
|
|
|
|
|
(bytevector? (query-path-hash %store p)))))))
|
|
|
|
|
|
2012-11-08 23:55:12 +01:00
|
|
|
|
(test-assert "derivation with a fixed-output input"
|
|
|
|
|
;; A derivation D using a fixed-output derivation F doesn't has the same
|
|
|
|
|
;; output path when passed F or F', as long as F and F' have the same output
|
|
|
|
|
;; path.
|
|
|
|
|
(let* ((builder1 (add-text-to-store %store "fixed-builder1.sh"
|
|
|
|
|
"echo -n hello > $out" '()))
|
|
|
|
|
(builder2 (add-text-to-store %store "fixed-builder2.sh"
|
|
|
|
|
"echo hey; echo -n hello > $out" '()))
|
|
|
|
|
(hash (sha256 (string->utf8 "hello")))
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(fixed1 (derivation %store "fixed"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder1)
|
2012-11-08 23:55:12 +01:00
|
|
|
|
#:hash hash #:hash-algo 'sha256))
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(fixed2 (derivation %store "fixed"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder2)
|
2012-11-08 23:55:12 +01:00
|
|
|
|
#:hash hash #:hash-algo 'sha256))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(fixed-out (derivation->output-path fixed1))
|
2012-11-08 23:55:12 +01:00
|
|
|
|
(builder3 (add-text-to-store
|
|
|
|
|
%store "final-builder.sh"
|
|
|
|
|
;; Use Bash hackery to avoid Coreutils.
|
|
|
|
|
"echo $in ; (read -u 3 c; echo $c) 3< $in > $out" '()))
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(final1 (derivation %store "final"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder3)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
#:env-vars `(("in" . ,fixed-out))
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash) (,builder3) (,fixed1))))
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(final2 (derivation %store "final"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder3)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
#:env-vars `(("in" . ,fixed-out))
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash) (,builder3) (,fixed2))))
|
2012-11-08 23:55:12 +01:00
|
|
|
|
(succeeded? (build-derivations %store
|
|
|
|
|
(list final1 final2))))
|
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(equal? (derivation->output-path final1)
|
|
|
|
|
(derivation->output-path final2)))))
|
2012-11-08 23:55:12 +01:00
|
|
|
|
|
2012-06-09 21:52:31 +02:00
|
|
|
|
(test-assert "multiple-output derivation"
|
|
|
|
|
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
|
|
|
|
|
"echo one > $out ; echo two > $second"
|
|
|
|
|
'()))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv (derivation %store "fixed"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
#:env-vars '(("HOME" . "/homeless")
|
|
|
|
|
("zzz" . "Z!")
|
|
|
|
|
("AAA" . "A!"))
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash) (,builder))
|
2012-06-09 21:52:31 +02:00
|
|
|
|
#:outputs '("out" "second")))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded? (build-derivations %store (list drv))))
|
2012-06-09 21:52:31 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((one (derivation->output-path drv "out"))
|
|
|
|
|
(two (derivation->output-path drv "second")))
|
2013-01-05 23:51:13 +01:00
|
|
|
|
(and (lset= equal?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(derivation->output-paths drv)
|
2013-01-05 23:51:13 +01:00
|
|
|
|
`(("out" . ,one) ("second" . ,two)))
|
|
|
|
|
(eq? 'one (call-with-input-file one read))
|
2012-06-09 21:52:31 +02:00
|
|
|
|
(eq? 'two (call-with-input-file two read)))))))
|
|
|
|
|
|
2012-07-01 15:37:58 +02:00
|
|
|
|
(test-assert "multiple-output derivation, non-alphabetic order"
|
|
|
|
|
;; Here, the outputs are not listed in alphabetic order. Yet, the store
|
|
|
|
|
;; path computation must reorder them first.
|
|
|
|
|
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
|
|
|
|
|
"echo one > $out ; echo two > $AAA"
|
|
|
|
|
'()))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv (derivation %store "fixed"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder)
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash) (,builder))
|
2012-07-01 15:37:58 +02:00
|
|
|
|
#:outputs '("out" "AAA")))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded? (build-derivations %store (list drv))))
|
2012-07-01 15:37:58 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((one (derivation->output-path drv "out"))
|
|
|
|
|
(two (derivation->output-path drv "AAA")))
|
2012-07-01 15:37:58 +02:00
|
|
|
|
(and (eq? 'one (call-with-input-file one read))
|
|
|
|
|
(eq? 'two (call-with-input-file two read)))))))
|
|
|
|
|
|
2016-05-19 23:27:48 +02:00
|
|
|
|
(test-assert "read-derivation vs. derivation"
|
|
|
|
|
;; Make sure 'derivation' and 'read-derivation' return objects that are
|
|
|
|
|
;; identical.
|
|
|
|
|
(let* ((sources (unfold (cut >= <> 10)
|
|
|
|
|
(lambda (n)
|
|
|
|
|
(add-text-to-store %store
|
|
|
|
|
(format #f "input~a" n)
|
|
|
|
|
(random-text)))
|
|
|
|
|
1+
|
|
|
|
|
0))
|
|
|
|
|
(inputs (map (lambda (file)
|
|
|
|
|
(derivation %store "derivation-input"
|
|
|
|
|
%bash '()
|
|
|
|
|
#:inputs `((,%bash) (,file))))
|
|
|
|
|
sources))
|
|
|
|
|
(builder (add-text-to-store %store "builder.sh"
|
|
|
|
|
"echo one > $one ; echo two > $two"
|
|
|
|
|
'()))
|
|
|
|
|
(drv (derivation %store "derivation"
|
|
|
|
|
%bash `(,builder)
|
|
|
|
|
#:inputs `((,%bash) (,builder)
|
|
|
|
|
,@(map list (append sources inputs)))
|
|
|
|
|
#:outputs '("two" "one")))
|
|
|
|
|
(drv* (call-with-input-file (derivation-file-name drv)
|
|
|
|
|
read-derivation)))
|
|
|
|
|
(equal? drv* drv)))
|
|
|
|
|
|
2013-10-30 19:09:32 +01:00
|
|
|
|
(test-assert "multiple-output derivation, derivation-path->output-path"
|
|
|
|
|
(let* ((builder (add-text-to-store %store "builder.sh"
|
|
|
|
|
"echo one > $out ; echo two > $second"
|
|
|
|
|
'()))
|
|
|
|
|
(drv (derivation %store "multiple"
|
|
|
|
|
%bash `(,builder)
|
|
|
|
|
#:outputs '("out" "second")))
|
|
|
|
|
(drv-file (derivation-file-name drv))
|
|
|
|
|
(one (derivation->output-path drv "out"))
|
|
|
|
|
(two (derivation->output-path drv "second"))
|
|
|
|
|
(first (derivation-path->output-path drv-file "out"))
|
|
|
|
|
(second (derivation-path->output-path drv-file "second")))
|
|
|
|
|
(and (not (string=? one two))
|
|
|
|
|
(string-suffix? "-second" two)
|
|
|
|
|
(string=? first one)
|
|
|
|
|
(string=? second two))))
|
|
|
|
|
|
2012-07-02 01:23:39 +02:00
|
|
|
|
(test-assert "user of multiple-output derivation"
|
|
|
|
|
;; Check whether specifying several inputs coming from the same
|
|
|
|
|
;; multiple-output derivation works.
|
|
|
|
|
(let* ((builder1 (add-text-to-store %store "my-mo-builder.sh"
|
|
|
|
|
"echo one > $out ; echo two > $two"
|
|
|
|
|
'()))
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(mdrv (derivation %store "multiple-output"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder1)
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash) (,builder1))
|
2012-07-02 01:23:39 +02:00
|
|
|
|
#:outputs '("out" "two")))
|
|
|
|
|
(builder2 (add-text-to-store %store "my-mo-user-builder.sh"
|
|
|
|
|
"read x < $one;
|
|
|
|
|
read y < $two;
|
|
|
|
|
echo \"($x $y)\" > $out"
|
|
|
|
|
'()))
|
|
|
|
|
(udrv (derivation %store "multiple-output-user"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder2)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
#:env-vars `(("one"
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
. ,(derivation->output-path
|
2013-08-26 22:11:04 +02:00
|
|
|
|
mdrv "out"))
|
|
|
|
|
("two"
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
. ,(derivation->output-path
|
2013-08-26 22:11:04 +02:00
|
|
|
|
mdrv "two")))
|
2013-11-04 23:06:13 +01:00
|
|
|
|
#:inputs `((,%bash)
|
|
|
|
|
(,builder2)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
;; two occurrences of MDRV:
|
|
|
|
|
(,mdrv)
|
|
|
|
|
(,mdrv "two")))))
|
2012-07-02 01:23:39 +02:00
|
|
|
|
(and (build-derivations %store (list (pk 'udrv udrv)))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((p (derivation->output-path udrv)))
|
2012-07-02 01:23:39 +02:00
|
|
|
|
(and (valid-path? %store p)
|
|
|
|
|
(equal? '(one two) (call-with-input-file p read)))))))
|
|
|
|
|
|
2013-08-27 18:34:49 +02:00
|
|
|
|
(test-assert "derivation with #:references-graphs"
|
2013-08-26 22:12:46 +02:00
|
|
|
|
(let* ((input1 (add-text-to-store %store "foo" "hello"
|
|
|
|
|
(list %bash)))
|
|
|
|
|
(input2 (add-text-to-store %store "bar"
|
|
|
|
|
(number->string (random 7777))
|
|
|
|
|
(list input1)))
|
|
|
|
|
(builder (add-text-to-store %store "build-graph"
|
|
|
|
|
(format #f "
|
|
|
|
|
~a $out
|
|
|
|
|
(while read l ; do echo $l ; done) < bash > $out/bash
|
|
|
|
|
(while read l ; do echo $l ; done) < input1 > $out/input1
|
|
|
|
|
(while read l ; do echo $l ; done) < input2 > $out/input2"
|
|
|
|
|
%mkdir)
|
|
|
|
|
(list %mkdir)))
|
|
|
|
|
(drv (derivation %store "closure-graphs"
|
|
|
|
|
%bash `(,builder)
|
2013-08-27 18:34:49 +02:00
|
|
|
|
#:references-graphs
|
2013-08-26 22:12:46 +02:00
|
|
|
|
`(("bash" . ,%bash)
|
|
|
|
|
("input1" . ,input1)
|
|
|
|
|
("input2" . ,input2))
|
|
|
|
|
#:inputs `((,%bash) (,builder))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(out (derivation->output-path drv)))
|
2013-08-26 22:12:46 +02:00
|
|
|
|
(define (deps path . deps)
|
|
|
|
|
(let ((count (length deps)))
|
|
|
|
|
(string-append path "\n\n" (number->string count) "\n"
|
|
|
|
|
(string-join (sort deps string<?) "\n")
|
|
|
|
|
(if (zero? count) "" "\n"))))
|
|
|
|
|
|
|
|
|
|
(and (build-derivations %store (list drv))
|
|
|
|
|
(equal? (directory-contents out get-string-all)
|
|
|
|
|
`(("/bash" . ,(string-append %bash "\n\n0\n"))
|
|
|
|
|
("/input1" . ,(if (string>? input1 %bash)
|
|
|
|
|
(string-append (deps %bash)
|
|
|
|
|
(deps input1 %bash))
|
|
|
|
|
(string-append (deps input1 %bash)
|
|
|
|
|
(deps %bash))))
|
|
|
|
|
("/input2" . ,(string-concatenate
|
|
|
|
|
(map cdr
|
|
|
|
|
(sort
|
|
|
|
|
(map (lambda (p d)
|
|
|
|
|
(cons p (apply deps p d)))
|
|
|
|
|
(list %bash input1 input2)
|
|
|
|
|
(list '() (list %bash) (list input1)))
|
|
|
|
|
(lambda (x y)
|
|
|
|
|
(match x
|
|
|
|
|
((p1 . _)
|
|
|
|
|
(match y
|
|
|
|
|
((p2 . _)
|
|
|
|
|
(string<? p1 p2)))))))))))))))
|
|
|
|
|
|
2014-06-01 23:32:26 +02:00
|
|
|
|
(test-assert "derivation #:allowed-references, ok"
|
|
|
|
|
(let ((drv (derivation %store "allowed" %bash
|
|
|
|
|
'("-c" "echo hello > $out")
|
|
|
|
|
#:inputs `((,%bash))
|
|
|
|
|
#:allowed-references '())))
|
|
|
|
|
(build-derivations %store (list drv))))
|
|
|
|
|
|
|
|
|
|
(test-assert "derivation #:allowed-references, not allowed"
|
|
|
|
|
(let* ((txt (add-text-to-store %store "foo" "Hello, world."))
|
|
|
|
|
(drv (derivation %store "disallowed" %bash
|
|
|
|
|
`("-c" ,(string-append "echo " txt "> $out"))
|
|
|
|
|
#:inputs `((,%bash) (,txt))
|
|
|
|
|
#:allowed-references '())))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
2014-06-01 23:32:26 +02:00
|
|
|
|
;; There's no specific error message to check for.
|
|
|
|
|
#t))
|
|
|
|
|
(build-derivations %store (list drv))
|
|
|
|
|
#f)))
|
|
|
|
|
|
|
|
|
|
(test-assert "derivation #:allowed-references, self allowed"
|
|
|
|
|
(let ((drv (derivation %store "allowed" %bash
|
|
|
|
|
'("-c" "echo $out > $out")
|
|
|
|
|
#:inputs `((,%bash))
|
|
|
|
|
#:allowed-references '("out"))))
|
|
|
|
|
(build-derivations %store (list drv))))
|
|
|
|
|
|
|
|
|
|
(test-assert "derivation #:allowed-references, self not allowed"
|
|
|
|
|
(let ((drv (derivation %store "disallowed" %bash
|
|
|
|
|
`("-c" ,"echo $out > $out")
|
|
|
|
|
#:inputs `((,%bash))
|
|
|
|
|
#:allowed-references '())))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
2014-06-01 23:32:26 +02:00
|
|
|
|
;; There's no specific error message to check for.
|
|
|
|
|
#t))
|
|
|
|
|
(build-derivations %store (list drv))
|
|
|
|
|
#f)))
|
|
|
|
|
|
2016-03-20 22:40:31 +01:00
|
|
|
|
(test-assert "derivation #:disallowed-references, ok"
|
|
|
|
|
(let ((drv (derivation %store "disallowed" %bash
|
|
|
|
|
'("-c" "echo hello > $out")
|
|
|
|
|
#:inputs `((,%bash))
|
|
|
|
|
#:disallowed-references '("out"))))
|
|
|
|
|
(build-derivations %store (list drv))))
|
|
|
|
|
|
|
|
|
|
(test-assert "derivation #:disallowed-references, not ok"
|
|
|
|
|
(let* ((txt (add-text-to-store %store "foo" "Hello, world."))
|
|
|
|
|
(drv (derivation %store "disdisallowed" %bash
|
|
|
|
|
`("-c" ,(string-append "echo " txt "> $out"))
|
|
|
|
|
#:inputs `((,%bash) (,txt))
|
|
|
|
|
#:disallowed-references (list txt))))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
2016-03-20 22:40:31 +01:00
|
|
|
|
;; There's no specific error message to check for.
|
|
|
|
|
#t))
|
|
|
|
|
(build-derivations %store (list drv))
|
|
|
|
|
#f)))
|
|
|
|
|
|
2019-02-03 22:10:06 +01:00
|
|
|
|
;; Here we should get the value of $GUIX_STATE_DIRECTORY that the daemon sees,
|
|
|
|
|
;; which is a unique value for each test process; this value is the same as
|
|
|
|
|
;; the one we see in the process executing this file since it is set by
|
|
|
|
|
;; 'test-env'.
|
2016-01-18 15:13:30 +01:00
|
|
|
|
(test-equal "derivation #:leaked-env-vars"
|
2019-02-03 22:10:06 +01:00
|
|
|
|
(getenv "GUIX_STATE_DIRECTORY")
|
|
|
|
|
(let* ((value (getenv "GUIX_STATE_DIRECTORY"))
|
2016-01-18 15:13:30 +01:00
|
|
|
|
(drv (derivation %store "leaked-env-vars" %bash
|
2019-02-03 22:10:06 +01:00
|
|
|
|
'("-c" "echo -n $GUIX_STATE_DIRECTORY > $out")
|
2016-01-18 15:13:30 +01:00
|
|
|
|
#:hash (sha256 (string->utf8 value))
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:inputs `((,%bash))
|
2019-02-03 22:10:06 +01:00
|
|
|
|
#:leaked-env-vars '("GUIX_STATE_DIRECTORY"))))
|
2016-01-18 15:13:30 +01:00
|
|
|
|
(and (build-derivations %store (list drv))
|
|
|
|
|
(call-with-input-file (derivation->output-path drv)
|
|
|
|
|
get-string-all))))
|
|
|
|
|
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
|
|
|
|
(define %coreutils
|
2012-10-28 01:58:39 +02:00
|
|
|
|
(false-if-exception
|
2015-02-23 23:41:26 +01:00
|
|
|
|
(and (network-reachable?)
|
2015-10-06 22:33:03 +02:00
|
|
|
|
(package-derivation %store %bootstrap-coreutils&co))))
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
|
|
|
|
(test-skip (if %coreutils 0 1))
|
|
|
|
|
|
|
|
|
|
(test-assert "build derivation with coreutils"
|
|
|
|
|
(let* ((builder
|
|
|
|
|
(add-text-to-store %store "build-with-coreutils.sh"
|
|
|
|
|
"echo $PATH ; mkdir --version ; mkdir $out ; touch $out/good"
|
|
|
|
|
'()))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv
|
2013-08-26 22:11:04 +02:00
|
|
|
|
(derivation %store "foo"
|
2013-01-02 01:04:37 +01:00
|
|
|
|
%bash `(,builder)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
#:env-vars `(("PATH" .
|
|
|
|
|
,(string-append
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(derivation->output-path %coreutils)
|
2013-08-26 22:11:04 +02:00
|
|
|
|
"/bin")))
|
|
|
|
|
#:inputs `((,builder)
|
|
|
|
|
(,%coreutils))))
|
2012-06-07 23:15:00 +02:00
|
|
|
|
(succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(build-derivations %store (list drv))))
|
2012-06-07 23:15:00 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((p (derivation->output-path drv)))
|
2012-07-01 00:21:16 +02:00
|
|
|
|
(and (valid-path? %store p)
|
|
|
|
|
(file-exists? (string-append p "/good")))))))
|
2012-06-07 23:15:00 +02:00
|
|
|
|
|
2013-08-26 22:19:21 +02:00
|
|
|
|
(test-skip (if (%guile-for-build) 0 8))
|
2012-07-01 00:37:03 +02:00
|
|
|
|
|
2016-03-22 15:00:53 +01:00
|
|
|
|
(test-equal "build-expression->derivation and invalid module name"
|
|
|
|
|
'(file-search-error "guix/module/that/does/not/exist.scm")
|
|
|
|
|
(guard (c ((file-search-error? c)
|
|
|
|
|
(list 'file-search-error
|
|
|
|
|
(file-search-error-file-name c))))
|
|
|
|
|
(build-expression->derivation %store "foo" #t
|
|
|
|
|
#:modules '((guix module that
|
|
|
|
|
does not exist)))))
|
|
|
|
|
|
2017-04-21 22:43:28 +02:00
|
|
|
|
(test-equal "build-expression->derivation and builder encoding"
|
|
|
|
|
'("UTF-8" #t)
|
|
|
|
|
(let* ((exp '(λ (α) (+ α 1)))
|
|
|
|
|
(drv (build-expression->derivation %store "foo" exp)))
|
|
|
|
|
(match (derivation-builder-arguments drv)
|
|
|
|
|
((... builder)
|
2017-04-22 14:05:38 +02:00
|
|
|
|
(with-fluids ((%default-port-encoding "UTF-8"))
|
|
|
|
|
(call-with-input-file builder
|
|
|
|
|
(lambda (port)
|
|
|
|
|
(list (port-encoding port)
|
|
|
|
|
(->bool
|
|
|
|
|
(string-contains (get-string-all port)
|
|
|
|
|
"(λ (α) (+ α 1))"))))))))))
|
2017-04-21 22:43:28 +02:00
|
|
|
|
|
2012-07-01 00:37:03 +02:00
|
|
|
|
(test-assert "build-expression->derivation and derivation-prerequisites"
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(let ((drv (build-expression->derivation %store "fail" #f)))
|
2012-07-01 00:37:03 +02:00
|
|
|
|
(any (match-lambda
|
2019-06-23 11:28:29 +02:00
|
|
|
|
(($ <derivation-input> (= derivation-file-name path))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(string=? path (derivation-file-name (%guile-for-build)))))
|
2012-07-01 00:37:03 +02:00
|
|
|
|
(derivation-prerequisites drv))))
|
2012-06-08 21:31:01 +02:00
|
|
|
|
|
2015-05-27 09:36:43 +02:00
|
|
|
|
(test-assert "derivation-prerequisites and valid-derivation-input?"
|
2015-03-25 09:42:45 +01:00
|
|
|
|
(let* ((a (build-expression->derivation %store "a" '(mkdir %output)))
|
|
|
|
|
(b (build-expression->derivation %store "b" `(list ,(random-text))))
|
|
|
|
|
(c (build-expression->derivation %store "c" `(mkdir %output)
|
|
|
|
|
#:inputs `(("a" ,a) ("b" ,b)))))
|
2015-05-27 09:36:43 +02:00
|
|
|
|
;; Make sure both A and %BOOTSTRAP-GUILE are built (the latter could have
|
|
|
|
|
;; be removed by tests/guix-gc.sh.)
|
|
|
|
|
(build-derivations %store
|
|
|
|
|
(list a (package-derivation %store %bootstrap-guile)))
|
|
|
|
|
|
2015-03-25 09:42:45 +01:00
|
|
|
|
(match (derivation-prerequisites c
|
|
|
|
|
(cut valid-derivation-input? %store
|
|
|
|
|
<>))
|
2019-06-23 11:28:29 +02:00
|
|
|
|
((($ <derivation-input> (= derivation-file-name file) ("out")))
|
2015-03-25 09:42:45 +01:00
|
|
|
|
(string=? file (derivation-file-name b)))
|
|
|
|
|
(x
|
|
|
|
|
(pk 'fail x #f)))))
|
|
|
|
|
|
2012-06-08 21:31:01 +02:00
|
|
|
|
(test-assert "build-expression->derivation without inputs"
|
|
|
|
|
(let* ((builder '(begin
|
|
|
|
|
(mkdir %output)
|
|
|
|
|
(call-with-output-file (string-append %output "/test")
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(display '(hello guix) p)))))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(drv (build-expression->derivation %store "goo" builder))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded? (build-derivations %store (list drv))))
|
2012-06-08 21:31:01 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((p (derivation->output-path drv)))
|
2012-06-08 21:31:01 +02:00
|
|
|
|
(equal? '(hello guix)
|
|
|
|
|
(call-with-input-file (string-append p "/test") read))))))
|
|
|
|
|
|
2013-05-20 18:14:55 +02:00
|
|
|
|
(test-assert "build-expression->derivation and max-silent-time"
|
|
|
|
|
(let* ((store (let ((s (open-connection)))
|
|
|
|
|
(set-build-options s #:max-silent-time 1)
|
|
|
|
|
s))
|
2013-11-04 23:41:33 +01:00
|
|
|
|
(builder '(begin (sleep 100) (mkdir %output) #t))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(drv (build-expression->derivation store "silent" builder))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(out-path (derivation->output-path drv)))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
|
|
|
|
(and (string-contains (store-protocol-error-message c)
|
2014-03-09 23:01:18 +01:00
|
|
|
|
"failed")
|
|
|
|
|
(not (valid-path? store out-path)))))
|
|
|
|
|
(build-derivations store (list drv))
|
|
|
|
|
#f)))
|
|
|
|
|
|
|
|
|
|
(test-assert "build-expression->derivation and timeout"
|
|
|
|
|
(let* ((store (let ((s (open-connection)))
|
|
|
|
|
(set-build-options s #:timeout 1)
|
|
|
|
|
s))
|
|
|
|
|
(builder '(begin (sleep 100) (mkdir %output) #t))
|
|
|
|
|
(drv (build-expression->derivation store "slow" builder))
|
|
|
|
|
(out-path (derivation->output-path drv)))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
|
|
|
|
(and (string-contains (store-protocol-error-message c)
|
2013-05-20 18:14:55 +02:00
|
|
|
|
"failed")
|
|
|
|
|
(not (valid-path? store out-path)))))
|
2013-11-04 23:41:33 +01:00
|
|
|
|
(build-derivations store (list drv))
|
|
|
|
|
#f)))
|
2013-05-20 18:14:55 +02:00
|
|
|
|
|
2019-06-10 22:10:21 +02:00
|
|
|
|
(test-assert "build-derivations with specific output"
|
|
|
|
|
(with-store store
|
|
|
|
|
(let* ((content (random-text)) ;contents of the output
|
|
|
|
|
(drv (build-expression->derivation
|
|
|
|
|
store "substitute-me"
|
|
|
|
|
`(begin ,content (exit 1)) ;would fail
|
|
|
|
|
#:outputs '("out" "one" "two")
|
|
|
|
|
#:guile-for-build
|
|
|
|
|
(package-derivation store %bootstrap-guile)))
|
|
|
|
|
(out (derivation->output-path drv)))
|
|
|
|
|
(with-derivation-substitute drv content
|
|
|
|
|
(set-build-options store #:use-substitutes? #t
|
|
|
|
|
#:substitute-urls (%test-substitute-urls))
|
|
|
|
|
(and (has-substitutes? store out)
|
|
|
|
|
|
|
|
|
|
;; Ask for nothing but the "out" output of DRV.
|
|
|
|
|
(build-derivations store `((,drv . "out")))
|
|
|
|
|
|
2019-06-23 12:39:39 +02:00
|
|
|
|
;; Synonymous:
|
|
|
|
|
(build-derivations store (list (derivation-input drv '("out"))))
|
|
|
|
|
|
2019-06-10 22:10:21 +02:00
|
|
|
|
(valid-path? store out)
|
2019-06-23 12:39:39 +02:00
|
|
|
|
(equal? (pk 'x content)
|
|
|
|
|
(pk 'y (call-with-input-file out get-string-all))))))))
|
2019-06-10 22:10:21 +02:00
|
|
|
|
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(test-assert "build-expression->derivation and derivation-build-plan"
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(let ((drv (build-expression->derivation %store "fail" #f)))
|
2012-07-01 00:37:03 +02:00
|
|
|
|
;; The only direct dependency is (%guile-for-build) and it's already
|
|
|
|
|
;; built.
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(null? (derivation-build-plan %store (derivation-inputs drv)))))
|
2012-07-01 00:37:03 +02:00
|
|
|
|
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(test-assert "derivation-build-plan when outputs already present"
|
2019-06-17 22:48:44 +02:00
|
|
|
|
(let* ((builder `(begin ,(random-text) (mkdir %output) #t))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(input-drv (build-expression->derivation %store "input" builder))
|
2019-06-17 22:48:44 +02:00
|
|
|
|
(input-path (derivation->output-path input-drv))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(drv (build-expression->derivation %store "something" builder
|
|
|
|
|
#:inputs
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
`(("i" ,input-drv))))
|
|
|
|
|
(output (derivation->output-path drv)))
|
2019-06-17 22:48:44 +02:00
|
|
|
|
;; Assume these things are not already built.
|
|
|
|
|
(when (or (valid-path? %store input-path)
|
|
|
|
|
(valid-path? %store output))
|
|
|
|
|
(error "things already built" input-drv))
|
2013-01-09 08:38:57 +01:00
|
|
|
|
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(and (lset= equal?
|
|
|
|
|
(map derivation-file-name
|
|
|
|
|
(derivation-build-plan %store
|
|
|
|
|
(list (derivation-input drv))))
|
|
|
|
|
(list (derivation-file-name input-drv)
|
|
|
|
|
(derivation-file-name drv)))
|
2013-01-09 08:38:57 +01:00
|
|
|
|
|
|
|
|
|
;; Build DRV and delete its input.
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(build-derivations %store (list drv))
|
2013-01-09 08:38:57 +01:00
|
|
|
|
(delete-paths %store (list input-path))
|
|
|
|
|
(not (valid-path? %store input-path))
|
|
|
|
|
|
|
|
|
|
;; Now INPUT-PATH is missing, yet it shouldn't be listed as a
|
|
|
|
|
;; prerequisite to build because DRV itself is already built.
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(null? (derivation-build-plan %store
|
|
|
|
|
(list (derivation-input drv)))))))
|
2013-01-09 08:38:57 +01:00
|
|
|
|
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(test-assert "derivation-build-plan and substitutes"
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let* ((store (open-connection))
|
|
|
|
|
(drv (build-expression->derivation store "prereq-subst"
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(random 1000)))
|
2014-10-29 00:09:38 +01:00
|
|
|
|
(output (derivation->output-path drv)))
|
2013-04-17 00:06:59 +02:00
|
|
|
|
|
2014-03-22 22:55:58 +01:00
|
|
|
|
;; Make sure substitutes are usable.
|
substitute: Honor "substitute-urls" option passed by "untrusted" clients.
* guix/scripts/substitute.scm (or*): New macro.
(%cache-url): Honor "untrusted-substitute-urls".
* guix/tests.scm (%test-substitute-urls): New variable.
(open-connection-for-tests): Use it.
* tests/derivations.scm ("derivation-prerequisites-to-build and substitutes",
"derivation-prerequisites-to-build and substitutes, non-substitutable
build", "derivation-prerequisites-to-build and substitutes, local build"):
Pass it to 'set-build-options'.
* tests/guix-daemon.sh: Likewise.
* tests/store.scm ("substitute query, alternating URLs"): New test.
("substitute query", "substitute", "substitute + build-things with output
path", "substitute, corrupt output hash", "substitute --fallback"): Pass
#:substitute-urls to 'set-build-options'.
2015-07-13 15:46:12 +02:00
|
|
|
|
(set-build-options store #:use-substitutes? #t
|
|
|
|
|
#:substitute-urls (%test-substitute-urls))
|
2014-03-22 22:55:58 +01:00
|
|
|
|
|
2014-10-29 00:09:38 +01:00
|
|
|
|
(with-derivation-narinfo drv
|
|
|
|
|
(let-values (((build download)
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(derivation-build-plan store
|
|
|
|
|
(list (derivation-input drv))))
|
2014-10-29 00:09:38 +01:00
|
|
|
|
((build* download*)
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(derivation-build-plan store
|
|
|
|
|
(list (derivation-input drv))
|
|
|
|
|
#:substitutable-info
|
|
|
|
|
(const #f))))
|
2014-10-29 00:09:38 +01:00
|
|
|
|
(and (null? build)
|
2017-05-31 11:06:42 +02:00
|
|
|
|
(equal? (map substitutable-path download) (list output))
|
2014-10-29 00:09:38 +01:00
|
|
|
|
(null? download*)
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(equal? (list drv) build*))))))
|
2013-04-17 00:06:59 +02:00
|
|
|
|
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(test-assert "derivation-build-plan and substitutes, non-substitutable build"
|
2014-10-29 00:26:05 +01:00
|
|
|
|
(let* ((store (open-connection))
|
2015-07-03 00:05:16 +02:00
|
|
|
|
(drv (build-expression->derivation store "prereq-no-subst"
|
2014-10-29 00:26:05 +01:00
|
|
|
|
(random 1000)
|
2015-07-03 00:05:16 +02:00
|
|
|
|
#:substitutable? #f))
|
2014-10-29 00:26:05 +01:00
|
|
|
|
(output (derivation->output-path drv)))
|
|
|
|
|
|
|
|
|
|
;; Make sure substitutes are usable.
|
substitute: Honor "substitute-urls" option passed by "untrusted" clients.
* guix/scripts/substitute.scm (or*): New macro.
(%cache-url): Honor "untrusted-substitute-urls".
* guix/tests.scm (%test-substitute-urls): New variable.
(open-connection-for-tests): Use it.
* tests/derivations.scm ("derivation-prerequisites-to-build and substitutes",
"derivation-prerequisites-to-build and substitutes, non-substitutable
build", "derivation-prerequisites-to-build and substitutes, local build"):
Pass it to 'set-build-options'.
* tests/guix-daemon.sh: Likewise.
* tests/store.scm ("substitute query, alternating URLs"): New test.
("substitute query", "substitute", "substitute + build-things with output
path", "substitute, corrupt output hash", "substitute --fallback"): Pass
#:substitute-urls to 'set-build-options'.
2015-07-13 15:46:12 +02:00
|
|
|
|
(set-build-options store #:use-substitutes? #t
|
|
|
|
|
#:substitute-urls (%test-substitute-urls))
|
2014-10-29 00:26:05 +01:00
|
|
|
|
|
|
|
|
|
(with-derivation-narinfo drv
|
|
|
|
|
(let-values (((build download)
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(derivation-build-plan store
|
|
|
|
|
(list (derivation-input drv)))))
|
2014-10-29 00:26:05 +01:00
|
|
|
|
;; Despite being available as a substitute, DRV will be built locally
|
2015-07-03 00:05:16 +02:00
|
|
|
|
;; due to #:substitutable? #f.
|
2014-10-29 00:26:05 +01:00
|
|
|
|
(and (null? download)
|
|
|
|
|
(match build
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(((= derivation-file-name build))
|
|
|
|
|
(string=? build (derivation-file-name drv)))))))))
|
2014-10-29 00:26:05 +01:00
|
|
|
|
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(test-assert "derivation-build-plan and substitutes, local build"
|
2015-07-03 00:05:16 +02:00
|
|
|
|
(with-store store
|
|
|
|
|
(let* ((drv (build-expression->derivation store "prereq-subst-local"
|
|
|
|
|
(random 1000)
|
|
|
|
|
#:local-build? #t))
|
|
|
|
|
(output (derivation->output-path drv)))
|
|
|
|
|
|
|
|
|
|
;; Make sure substitutes are usable.
|
substitute: Honor "substitute-urls" option passed by "untrusted" clients.
* guix/scripts/substitute.scm (or*): New macro.
(%cache-url): Honor "untrusted-substitute-urls".
* guix/tests.scm (%test-substitute-urls): New variable.
(open-connection-for-tests): Use it.
* tests/derivations.scm ("derivation-prerequisites-to-build and substitutes",
"derivation-prerequisites-to-build and substitutes, non-substitutable
build", "derivation-prerequisites-to-build and substitutes, local build"):
Pass it to 'set-build-options'.
* tests/guix-daemon.sh: Likewise.
* tests/store.scm ("substitute query, alternating URLs"): New test.
("substitute query", "substitute", "substitute + build-things with output
path", "substitute, corrupt output hash", "substitute --fallback"): Pass
#:substitute-urls to 'set-build-options'.
2015-07-13 15:46:12 +02:00
|
|
|
|
(set-build-options store #:use-substitutes? #t
|
|
|
|
|
#:substitute-urls (%test-substitute-urls))
|
2015-07-03 00:05:16 +02:00
|
|
|
|
|
|
|
|
|
(with-derivation-narinfo drv
|
|
|
|
|
(let-values (((build download)
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(derivation-build-plan store
|
|
|
|
|
(list (derivation-input drv)))))
|
2015-09-05 22:08:47 +02:00
|
|
|
|
;; #:local-build? is *not* synonymous with #:substitutable?, so we
|
2015-07-03 00:05:16 +02:00
|
|
|
|
;; must be able to substitute DRV's output.
|
|
|
|
|
;; See <http://bugs.gnu.org/18747>.
|
|
|
|
|
(and (null? build)
|
|
|
|
|
(match download
|
2017-05-31 11:06:42 +02:00
|
|
|
|
(((= substitutable-path item))
|
2015-07-03 00:05:16 +02:00
|
|
|
|
(string=? item (derivation->output-path drv))))))))))
|
|
|
|
|
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(test-assert "derivation-build-plan in 'check' mode"
|
2015-12-09 10:30:03 +01:00
|
|
|
|
(with-store store
|
|
|
|
|
(let* ((dep (build-expression->derivation store "dep"
|
|
|
|
|
`(begin ,(random-text)
|
|
|
|
|
(mkdir %output))))
|
|
|
|
|
(drv (build-expression->derivation store "to-check"
|
|
|
|
|
'(mkdir %output)
|
|
|
|
|
#:inputs `(("dep" ,dep)))))
|
|
|
|
|
(build-derivations store (list drv))
|
|
|
|
|
(delete-paths store (list (derivation->output-path dep)))
|
|
|
|
|
|
|
|
|
|
;; In 'check' mode, DEP must be rebuilt.
|
2019-06-19 22:05:06 +02:00
|
|
|
|
(and (null? (derivation-build-plan store
|
|
|
|
|
(list (derivation-input drv))))
|
|
|
|
|
(lset= equal?
|
|
|
|
|
(derivation-build-plan store
|
|
|
|
|
(list (derivation-input drv))
|
|
|
|
|
#:mode (build-mode check))
|
|
|
|
|
(list drv dep))))))
|
2015-12-09 10:30:03 +01:00
|
|
|
|
|
2017-03-28 09:50:28 +02:00
|
|
|
|
(test-assert "substitution-oracle and #:substitute? #f"
|
|
|
|
|
(with-store store
|
|
|
|
|
(let* ((dep (build-expression->derivation store "dep"
|
|
|
|
|
`(begin ,(random-text)
|
|
|
|
|
(mkdir %output))))
|
|
|
|
|
(drv (build-expression->derivation store "not-subst"
|
|
|
|
|
`(begin ,(random-text)
|
|
|
|
|
(mkdir %output))
|
|
|
|
|
#:substitutable? #f
|
|
|
|
|
#:inputs `(("dep" ,dep))))
|
|
|
|
|
(query #f))
|
|
|
|
|
(define (record-substitutable-path-query store paths)
|
|
|
|
|
(when query
|
|
|
|
|
(error "already called!" query))
|
|
|
|
|
(set! query paths)
|
|
|
|
|
'())
|
|
|
|
|
|
2017-05-31 09:55:56 +02:00
|
|
|
|
(mock ((guix store) substitutable-path-info
|
2017-03-28 09:50:28 +02:00
|
|
|
|
record-substitutable-path-query)
|
|
|
|
|
|
|
|
|
|
(let ((pred (substitution-oracle store (list drv))))
|
|
|
|
|
(pred (derivation->output-path drv))))
|
|
|
|
|
|
|
|
|
|
;; Make sure the oracle didn't try to get substitute info for DRV since
|
|
|
|
|
;; DRV is mark as non-substitutable. Assume that GUILE-FOR-BUILD is
|
|
|
|
|
;; already in store and thus not part of QUERY.
|
|
|
|
|
(equal? (pk 'query query)
|
|
|
|
|
(list (derivation->output-path dep))))))
|
|
|
|
|
|
2012-06-16 16:46:29 +02:00
|
|
|
|
(test-assert "build-expression->derivation with expression returning #f"
|
|
|
|
|
(let* ((builder '(begin
|
|
|
|
|
(mkdir %output)
|
|
|
|
|
#f)) ; fail!
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(drv (build-expression->derivation %store "fail" builder))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(out-path (derivation->output-path drv)))
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(guard (c ((store-protocol-error? c)
|
2012-06-16 16:46:29 +02:00
|
|
|
|
;; Note that the output path may exist at this point, but it
|
|
|
|
|
;; is invalid.
|
2012-07-01 00:21:16 +02:00
|
|
|
|
(and (string-match "build .* failed"
|
store: Rename '&nix-error' to '&store-error'.
* guix/store.scm (&nix-error): Rename to...
(&store-error): ... this, and adjust users.
(&nix-connection-error): Rename to...
(&store-connection-error): ... this, and adjust users.
(&nix-protocol-error): Rename to...
(&store-protocol-error): ... this, adjust users.
(&nix-error, &nix-connection-error, &nix-protocol-error): Define these
condition types and their getters as deprecrated aliases.
* build-aux/run-system-tests.scm, guix/derivations.scm,
guix/grafts.scm, guix/scripts/challenge.scm,
guix/scripts/graph.scm, guix/scripts/lint.scm,
guix/scripts/offload.scm, guix/serialization.scm,
guix/ssh.scm, guix/tests.scm, guix/ui.scm,
tests/derivations.scm, tests/gexp.scm, tests/guix-daemon.sh,
tests/packages.scm, tests/store.scm, doc/guix.texi: Adjust to use the
new names.
2019-01-21 17:41:11 +01:00
|
|
|
|
(store-protocol-error-message c))
|
2012-07-01 00:21:16 +02:00
|
|
|
|
(not (valid-path? %store out-path)))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(build-derivations %store (list drv))
|
2012-06-16 16:46:29 +02:00
|
|
|
|
#f)))
|
|
|
|
|
|
2012-06-09 23:16:55 +02:00
|
|
|
|
(test-assert "build-expression->derivation with two outputs"
|
|
|
|
|
(let* ((builder '(begin
|
|
|
|
|
(call-with-output-file (assoc-ref %outputs "out")
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(display '(hello) p)))
|
|
|
|
|
(call-with-output-file (assoc-ref %outputs "second")
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(display '(world) p)))))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(drv (build-expression->derivation %store "double" builder
|
2012-06-09 23:16:55 +02:00
|
|
|
|
#:outputs '("out"
|
|
|
|
|
"second")))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded? (build-derivations %store (list drv))))
|
2012-06-09 23:16:55 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((one (derivation->output-path drv))
|
|
|
|
|
(two (derivation->output-path drv "second")))
|
2012-06-09 23:16:55 +02:00
|
|
|
|
(and (equal? '(hello) (call-with-input-file one read))
|
|
|
|
|
(equal? '(world) (call-with-input-file two read)))))))
|
|
|
|
|
|
2012-12-13 22:06:45 +01:00
|
|
|
|
(test-skip (if %coreutils 0 1))
|
2012-06-08 21:31:01 +02:00
|
|
|
|
(test-assert "build-expression->derivation with one input"
|
|
|
|
|
(let* ((builder '(call-with-output-file %output
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(let ((cu (assoc-ref %build-inputs "cu")))
|
|
|
|
|
(close 1)
|
|
|
|
|
(dup2 (port->fdes p) 1)
|
|
|
|
|
(execl (string-append cu "/bin/uname")
|
|
|
|
|
"uname" "-a")))))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(drv (build-expression->derivation %store "uname" builder
|
|
|
|
|
#:inputs
|
2012-06-13 17:21:27 +02:00
|
|
|
|
`(("cu" ,%coreutils))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(succeeded? (build-derivations %store (list drv))))
|
2012-06-08 21:31:01 +02:00
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(let ((p (derivation->output-path drv)))
|
2012-06-08 21:31:01 +02:00
|
|
|
|
(string-contains (call-with-input-file p read-line) "GNU")))))
|
|
|
|
|
|
2012-10-22 23:30:35 +02:00
|
|
|
|
(test-assert "build-expression->derivation with modules"
|
|
|
|
|
(let* ((builder `(begin
|
|
|
|
|
(use-modules (guix build utils))
|
|
|
|
|
(let ((out (assoc-ref %outputs "out")))
|
|
|
|
|
(mkdir-p (string-append out "/guile/guix/nix"))
|
|
|
|
|
#t)))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(drv (build-expression->derivation %store "test-with-modules"
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
builder
|
2012-10-22 23:30:35 +02:00
|
|
|
|
#:modules
|
|
|
|
|
'((guix build utils)))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(and (build-derivations %store (list drv))
|
|
|
|
|
(let* ((p (derivation->output-path drv))
|
2012-10-22 23:30:35 +02:00
|
|
|
|
(s (stat (string-append p "/guile/guix/nix"))))
|
|
|
|
|
(eq? (stat:type s) 'directory)))))
|
|
|
|
|
|
2012-11-08 23:55:12 +01:00
|
|
|
|
(test-assert "build-expression->derivation: same fixed-output path"
|
|
|
|
|
(let* ((builder1 '(call-with-output-file %output
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(write "hello" p))))
|
|
|
|
|
(builder2 '(call-with-output-file (pk 'difference-here! %output)
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(write "hello" p))))
|
|
|
|
|
(hash (sha256 (string->utf8 "hello")))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(input1 (build-expression->derivation %store "fixed" builder1
|
2012-11-08 23:55:12 +01:00
|
|
|
|
#:hash hash
|
|
|
|
|
#:hash-algo 'sha256))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(input2 (build-expression->derivation %store "fixed" builder2
|
2012-11-08 23:55:12 +01:00
|
|
|
|
#:hash hash
|
|
|
|
|
#:hash-algo 'sha256))
|
|
|
|
|
(succeeded? (build-derivations %store (list input1 input2))))
|
|
|
|
|
(and succeeded?
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(not (string=? (derivation-file-name input1)
|
|
|
|
|
(derivation-file-name input2)))
|
|
|
|
|
(string=? (derivation->output-path input1)
|
|
|
|
|
(derivation->output-path input2)))))
|
2012-11-08 23:55:12 +01:00
|
|
|
|
|
2012-11-09 00:07:10 +01:00
|
|
|
|
(test-assert "build-expression->derivation with a fixed-output input"
|
|
|
|
|
(let* ((builder1 '(call-with-output-file %output
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(write "hello" p))))
|
|
|
|
|
(builder2 '(call-with-output-file (pk 'difference-here! %output)
|
|
|
|
|
(lambda (p)
|
|
|
|
|
(write "hello" p))))
|
|
|
|
|
(hash (sha256 (string->utf8 "hello")))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(input1 (build-expression->derivation %store "fixed" builder1
|
2012-11-09 00:07:10 +01:00
|
|
|
|
#:hash hash
|
|
|
|
|
#:hash-algo 'sha256))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(input2 (build-expression->derivation %store "fixed" builder2
|
2012-11-09 00:07:10 +01:00
|
|
|
|
#:hash hash
|
|
|
|
|
#:hash-algo 'sha256))
|
|
|
|
|
(builder3 '(let ((input (assoc-ref %build-inputs "input")))
|
|
|
|
|
(call-with-output-file %output
|
|
|
|
|
(lambda (out)
|
|
|
|
|
(format #f "My input is ~a.~%" input)))))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(final1 (build-expression->derivation %store "final" builder3
|
|
|
|
|
#:inputs
|
2012-11-09 00:07:10 +01:00
|
|
|
|
`(("input" ,input1))))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(final2 (build-expression->derivation %store "final" builder3
|
|
|
|
|
#:inputs
|
2012-11-09 00:07:10 +01:00
|
|
|
|
`(("input" ,input2)))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(and (string=? (derivation->output-path final1)
|
|
|
|
|
(derivation->output-path final2))
|
|
|
|
|
(string=? (derivation->output-path final1)
|
|
|
|
|
(derivation-path->output-path
|
|
|
|
|
(derivation-file-name final1)))
|
2012-11-09 00:07:10 +01:00
|
|
|
|
(build-derivations %store (list final1 final2)))))
|
|
|
|
|
|
2014-02-21 23:03:19 +01:00
|
|
|
|
(test-assert "build-expression->derivation produces recursive fixed-output"
|
|
|
|
|
(let* ((builder '(begin
|
|
|
|
|
(use-modules (srfi srfi-26))
|
|
|
|
|
(mkdir %output)
|
|
|
|
|
(chdir %output)
|
|
|
|
|
(call-with-output-file "exe"
|
|
|
|
|
(cut display "executable" <>))
|
|
|
|
|
(chmod "exe" #o777)
|
|
|
|
|
(symlink "exe" "symlink")
|
|
|
|
|
(mkdir "subdir")))
|
|
|
|
|
(drv (build-expression->derivation %store "fixed-rec" builder
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:hash (base32
|
|
|
|
|
"10k1lw41wyrjf9mxydi0is5nkpynlsvgslinics4ppir13g7d74p")
|
|
|
|
|
#:recursive? #t)))
|
|
|
|
|
(and (build-derivations %store (list drv))
|
|
|
|
|
(let* ((dir (derivation->output-path drv))
|
|
|
|
|
(exe (string-append dir "/exe"))
|
|
|
|
|
(link (string-append dir "/symlink"))
|
|
|
|
|
(subdir (string-append dir "/subdir")))
|
|
|
|
|
(and (executable-file? exe)
|
|
|
|
|
(string=? "executable"
|
|
|
|
|
(call-with-input-file exe get-string-all))
|
|
|
|
|
(string=? "exe" (readlink link))
|
|
|
|
|
(file-is-directory? subdir))))))
|
|
|
|
|
|
|
|
|
|
(test-assert "build-expression->derivation uses recursive fixed-output"
|
|
|
|
|
(let* ((builder '(call-with-output-file %output
|
|
|
|
|
(lambda (port)
|
|
|
|
|
(display "hello" port))))
|
|
|
|
|
(fixed (build-expression->derivation %store "small-fixed-rec"
|
|
|
|
|
builder
|
|
|
|
|
#:hash-algo 'sha256
|
|
|
|
|
#:hash (base32
|
|
|
|
|
"0sg9f58l1jj88w6pdrfdpj5x9b1zrwszk84j81zvby36q9whhhqa")
|
|
|
|
|
#:recursive? #t))
|
|
|
|
|
(in (derivation->output-path fixed))
|
|
|
|
|
(builder `(begin
|
|
|
|
|
(mkdir %output)
|
|
|
|
|
(chdir %output)
|
|
|
|
|
(symlink ,in "symlink")))
|
|
|
|
|
(drv (build-expression->derivation %store "fixed-rec-user"
|
|
|
|
|
builder
|
|
|
|
|
#:inputs `(("fixed" ,fixed)))))
|
|
|
|
|
(and (build-derivations %store (list drv))
|
|
|
|
|
(let ((out (derivation->output-path drv)))
|
|
|
|
|
(string=? (readlink (string-append out "/symlink")) in)))))
|
|
|
|
|
|
2013-08-27 18:34:49 +02:00
|
|
|
|
(test-assert "build-expression->derivation with #:references-graphs"
|
2013-08-26 22:19:21 +02:00
|
|
|
|
(let* ((input (add-text-to-store %store "foo" "hello"
|
|
|
|
|
(list %bash %mkdir)))
|
|
|
|
|
(builder '(copy-file "input" %output))
|
2013-08-27 18:34:49 +02:00
|
|
|
|
(drv (build-expression->derivation %store "references-graphs"
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
builder
|
2013-08-27 18:34:49 +02:00
|
|
|
|
#:references-graphs
|
2013-08-26 22:19:21 +02:00
|
|
|
|
`(("input" . ,input))))
|
derivations: 'derivation' and related procedures return a single value.
* guix/derivations.scm (derivation->output-path,
derivation->output-paths): New procedures.
(derivation-path->output-path): Use 'derivation->output-path'.
(derivation-path->output-paths): Use 'derivation->output-paths'.
(derivation): Accept 'derivation?' objects as inputs. Return a single
value.
(build-derivations): New procedure.
(compiled-modules): Use 'derivation->output-paths'.
(build-expression->derivation)[source-path]: Add case for when the
input matches 'derivation?'.
[prologue]: Accept 'derivation?' objects in INPUTS.
[mod-dir, go-dir]: Use 'derivation->output-path'.
* guix/download.scm (url-fetch): Adjust to the single-value return.
* guix/packages.scm (package-output): Use 'derivation->output-path'.
* guix/scripts/build.scm (guix-build): When the argument is
'derivation-path?', pass it through 'read-derivation'.
Use 'derivation-file-name' to print out the .drv file names, and to
register them. Use 'derivation->output-path' instead of
'derivation-path->output-path'.
* guix/scripts/package.scm (roll-back): Adjust to the single-value
return.
(guix-package): Use 'derivation->output-path'.
* guix/ui.scm (show-what-to-build): Adjust to deal with 'derivation?'
objects instead of .drv file names.
* gnu/system/grub.scm (grub-configuration-file): Use
'derivation->output-path' instead of 'derivation-path->output-path'.
* gnu/system/vm.scm (qemu-image, system-qemu-image): Likewise.
* tests/builders.scm, tests/derivations.scm, tests/packages.scm,
tests/store.scm, tests/union.scm: Adjust to the new calling
convention.
* doc/guix.texi (Defining Packages, The Store, Derivations): Adjust
accordingly.
2013-09-18 17:01:40 +02:00
|
|
|
|
(out (derivation->output-path drv)))
|
2013-08-26 22:19:21 +02:00
|
|
|
|
(define (deps path . deps)
|
|
|
|
|
(let ((count (length deps)))
|
|
|
|
|
(string-append path "\n\n" (number->string count) "\n"
|
|
|
|
|
(string-join (sort deps string<?) "\n")
|
|
|
|
|
(if (zero? count) "" "\n"))))
|
|
|
|
|
|
|
|
|
|
(and (build-derivations %store (list drv))
|
|
|
|
|
(equal? (call-with-input-file out get-string-all)
|
|
|
|
|
(string-concatenate
|
|
|
|
|
(map cdr
|
|
|
|
|
(sort (map (lambda (p d)
|
|
|
|
|
(cons p (apply deps p d)))
|
|
|
|
|
(list input %bash %mkdir)
|
|
|
|
|
(list (list %bash %mkdir)
|
|
|
|
|
'() '()))
|
|
|
|
|
(lambda (x y)
|
|
|
|
|
(match x
|
|
|
|
|
((p1 . _)
|
|
|
|
|
(match y
|
|
|
|
|
((p2 . _)
|
|
|
|
|
(string<? p1 p2)))))))))))))
|
|
|
|
|
|
2018-11-26 22:14:11 +01:00
|
|
|
|
(test-equal "derivation-properties"
|
|
|
|
|
(list '() '((type . test)))
|
|
|
|
|
(let ((drv1 (build-expression->derivation %store "bar"
|
|
|
|
|
'(mkdir %output)))
|
|
|
|
|
(drv2 (build-expression->derivation %store "foo"
|
|
|
|
|
'(mkdir %output)
|
|
|
|
|
#:properties '((type . test)))))
|
|
|
|
|
(list (derivation-properties drv1)
|
|
|
|
|
(derivation-properties drv2))))
|
|
|
|
|
|
2013-11-13 00:25:57 +01:00
|
|
|
|
(test-equal "map-derivation"
|
|
|
|
|
"hello"
|
|
|
|
|
(let* ((joke (package-derivation %store guile-1.8))
|
|
|
|
|
(good (package-derivation %store %bootstrap-guile))
|
|
|
|
|
(drv1 (build-expression->derivation %store "original-drv1"
|
|
|
|
|
#f ; systematically fail
|
|
|
|
|
#:guile-for-build joke))
|
|
|
|
|
(drv2 (build-expression->derivation %store "original-drv2"
|
|
|
|
|
'(call-with-output-file %output
|
|
|
|
|
(lambda (p)
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
(display "hello" p)))))
|
2013-11-13 00:25:57 +01:00
|
|
|
|
(drv3 (build-expression->derivation %store "drv-to-remap"
|
|
|
|
|
'(let ((in (assoc-ref
|
|
|
|
|
%build-inputs "in")))
|
|
|
|
|
(copy-file in %output))
|
derivations: Use more keyword parameters for 'build-expression->derivation'.
* guix/derivations.scm (build-expression->derivation): Turn 'system' and
'inputs' into keyword parameters.
Adjust callers accordingly.
* gnu/system/linux.scm, gnu/system/vm.scm, guix/build-system/cmake.scm,
guix/build-system/gnu.scm, guix/build-system/perl.scm,
guix/build-system/python.scm, guix/build-system/trivial.scm,
guix/download.scm, guix/packages.scm, guix/profiles.scm,
guix/scripts/pull.scm, tests/derivations.scm, tests/guix-build.sh,
tests/monads.scm, tests/store.scm, tests/union.scm: Adjust users of
'build-expression->derivation' and 'derivation-expression'
accordingly.
* doc/guix.texi (Derivations): Adjust 'build-expression->derivation'
documentation accordingly.
(The Store Monad): Likewise for 'derivation-expression'.
2013-12-04 16:07:36 +01:00
|
|
|
|
#:inputs `(("in" ,drv1))
|
2013-11-13 00:25:57 +01:00
|
|
|
|
#:guile-for-build joke))
|
|
|
|
|
(drv4 (map-derivation %store drv3 `((,drv1 . ,drv2)
|
|
|
|
|
(,joke . ,good))))
|
|
|
|
|
(out (derivation->output-path drv4)))
|
|
|
|
|
(and (build-derivations %store (list (pk 'remapped drv4)))
|
|
|
|
|
(call-with-input-file out get-string-all))))
|
|
|
|
|
|
2013-11-13 11:22:07 +01:00
|
|
|
|
(test-equal "map-derivation, sources"
|
|
|
|
|
"hello"
|
|
|
|
|
(let* ((script1 (add-text-to-store %store "fail.sh" "exit 1"))
|
|
|
|
|
(script2 (add-text-to-store %store "hi.sh" "echo -n hello > $out"))
|
|
|
|
|
(bash-full (package-derivation %store (@ (gnu packages bash) bash)))
|
|
|
|
|
(drv1 (derivation %store "drv-to-remap"
|
|
|
|
|
|
|
|
|
|
;; XXX: This wouldn't work in practice, but if
|
|
|
|
|
;; we append "/bin/bash" then we can't replace
|
|
|
|
|
;; it with the bootstrap bash, which is a
|
|
|
|
|
;; single file.
|
|
|
|
|
(derivation->output-path bash-full)
|
|
|
|
|
|
|
|
|
|
`("-e" ,script1)
|
|
|
|
|
#:inputs `((,bash-full) (,script1))))
|
|
|
|
|
(drv2 (map-derivation %store drv1
|
|
|
|
|
`((,bash-full . ,%bash)
|
|
|
|
|
(,script1 . ,script2))))
|
|
|
|
|
(out (derivation->output-path drv2)))
|
|
|
|
|
(and (build-derivations %store (list (pk 'remapped* drv2)))
|
|
|
|
|
(call-with-input-file out get-string-all))))
|
|
|
|
|
|
2012-04-19 23:09:55 +02:00
|
|
|
|
(test-end)
|
2017-01-11 17:06:31 +01:00
|
|
|
|
|
|
|
|
|
;; Local Variables:
|
|
|
|
|
;; eval: (put 'with-http-server 'scheme-indent-function 2)
|
|
|
|
|
;; End:
|