Merge branch 'master' into core-updates

6 files changed, 133 insertions, 493 deletions

diff --git a/build-aux/build-self.scm b/build-aux/build-self.scm
index 5b281c3bc9..d18b4504cf 100644
--- a/build-aux/build-self.scm
+++ b/build-aux/build-self.scm
@@ -1,5 +1,5 @@
 ;;; GNU Guix --- Functional package management for GNU
-;;; Copyright © 2014, 2016, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2014, 2016, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -114,11 +114,11 @@
                      (define %state-directory
                        ;; This must match `NIX_STATE_DIR' as defined in
                        ;; `nix/local.mk'.
-                       (or (getenv "NIX_STATE_DIR")
+                       (or (getenv "GUIX_STATE_DIRECTORY")
                            (string-append %localstatedir "/guix")))
 
                      (define %store-database-directory
-                       (or (getenv "NIX_DB_DIR")
+                       (or (getenv "GUIX_DATABASE_DIRECTORY")
                            (string-append %state-directory "/db")))
 
                      (define %config-directory
@@ -293,9 +293,6 @@ interface (FFI) of Guile.")
                       (use-modules (ice-9 match))
 
                       (eval-when (expand load eval)
-                        ;; Don't augment '%load-path'.
-                        (unsetenv "GUIX_PACKAGE_PATH")
-
                         ;; (gnu packages …) modules are going to be looked up
                         ;; under SOURCE.  (guix config) is looked up in FRONT.
                         (match (command-line)
@@ -312,15 +309,11 @@ interface (FFI) of Guile.")
 
                         ;; Only load Guile-Gcrypt, our own modules, or those
                         ;; of Guile.
-                        (match %load-compiled-path
-                          ((front _ ... sys1 sys2)
-                           (unless (string-prefix? #$guile-gcrypt front)
-                             (set! %load-compiled-path
-                               (list (string-append #$guile-gcrypt
-                                                    "/lib/guile/"
-                                                    (effective-version)
-                                                    "/site-ccache")
-                                     front sys1 sys2))))))
+                        (set! %load-compiled-path
+                          (cons (string-append #$guile-gcrypt "/lib/guile/"
+                                               (effective-version)
+                                               "/site-ccache")
+                                %load-compiled-path)))
 
                       (use-modules (guix store)
                                    (guix self)
@@ -334,12 +327,13 @@ interface (FFI) of Guile.")
                         (format (current-error-port)
                                 "Computing Guix derivation for '~a'...  "
                                 system)
-                        (let loop ((spin spin))
-                          (display (string-append "\b" (car spin))
-                                   (current-error-port))
-                          (force-output (current-error-port))
-                          (sleep 1)
-                          (loop (cdr spin))))
+                        (when (isatty? (current-error-port))
+                          (let loop ((spin spin))
+                            (display (string-append "\b" (car spin))
+                                     (current-error-port))
+                            (force-output (current-error-port))
+                            (sleep 1)
+                            (loop (cdr spin)))))
 
                       (match (command-line)
                         ((_ source system version protocol-version)
@@ -371,6 +365,19 @@ interface (FFI) of Guile.")
                              derivation-file-name))))))
                   #:module-path (list source))))
 
+(define (call-with-clean-environment thunk)
+  (let ((env (environ)))
+    (dynamic-wind
+      (lambda ()
+        (environ '()))
+      thunk
+      (lambda ()
+        (environ env)))))
+
+(define-syntax-rule (with-clean-environment exp ...)
+  "Evaluate EXP in a context where zero environment variables are defined."
+  (call-with-clean-environment (lambda () exp ...)))
+
 ;; The procedure below is our return value.
 (define* (build source
                 #:key verbose? (version (date-version-string)) system
@@ -405,14 +412,17 @@ files."
       ;; stdin will actually be /dev/null.
       (let* ((pipe   (with-input-from-port port
                        (lambda ()
-                         (setenv "GUILE_WARN_DEPRECATED" "no") ;be quiet and drive
-                         (open-pipe* OPEN_READ
-                                     (derivation->output-path build)
-                                     source system version
-                                     (if (file-port? port)
-                                         (number->string
-                                          (logior major minor))
-                                         "none")))))
+                         ;; Make sure BUILD is not influenced by
+                         ;; $GUILE_LOAD_PATH & co.
+                         (with-clean-environment
+                          (setenv "GUILE_WARN_DEPRECATED" "no") ;be quiet and drive
+                          (open-pipe* OPEN_READ
+                                      (derivation->output-path build)
+                                      source system version
+                                      (if (file-port? port)
+                                          (number->string
+                                           (logior major minor))
+                                          "none"))))))
              (str    (get-string-all pipe))
              (status (close-pipe pipe)))
         (match str
@@ -420,7 +430,7 @@ files."
            (error "build program failed" (list build status)))
           ((? derivation-path? drv)
            (mbegin %store-monad
-             (return (newline (current-output-port)))
+             (return (newline (current-error-port)))
              ((store-lift add-temp-root) drv)
              (return (read-derivation-from-file drv))))
           ("#f"
diff --git a/build-aux/hydra/evaluate.scm b/build-aux/hydra/evaluate.scm
index 5793c022ff..adb14808fa 100644
--- a/build-aux/hydra/evaluate.scm
+++ b/build-aux/hydra/evaluate.scm
@@ -22,6 +22,8 @@
 ;;; arguments and outputs an sexp of the jobs on standard output.
 
 (use-modules (guix store)
+             (guix git-download)
+             ((guix build utils) #:select (with-directory-excursion))
              (srfi srfi-19)
              (ice-9 match)
              (ice-9 pretty-print)
@@ -81,11 +83,6 @@ Otherwise return THING."
    ;; Load FILE, a Scheme file that defines Hydra jobs.
    (let ((port (current-output-port))
          (real-build-things build-things))
-     (save-module-excursion
-      (lambda ()
-        (set-current-module %user-module)
-        (primitive-load file)))
-
      (with-store store
        ;; Make sure we don't resort to substitutes.
        (set-build-options store
@@ -104,23 +101,37 @@ Otherwise return THING."
                    "'build-things' arguments: ~s~%" args)
            (apply real-build-things store args)))
 
-       ;; Call the entry point of FILE and print the resulting job sexp.
-       (pretty-print
-        (match ((module-ref %user-module
-                            (if (equal? cuirass? "cuirass")
-                                'cuirass-jobs
-                                'hydra-jobs))
-                store `((guix
-                         . ((file-name . ,%top-srcdir)))))
-          (((names . thunks) ...)
-           (map (lambda (job thunk)
-                  (format (current-error-port) "evaluating '~a'... " job)
-                  (force-output (current-error-port))
-                  (cons job
-                        (assert-valid-job job
-                                          (call-with-time-display thunk))))
-                names thunks)))
-        port))))
+       ;; Add %TOP-SRCDIR to the store with a proper Git predicate so we work
+       ;; from a clean checkout
+       (let ((source (add-to-store store "guix-source" #t
+                                   "sha256" %top-srcdir
+                                   #:select? (git-predicate %top-srcdir))))
+         (with-directory-excursion source
+           (save-module-excursion
+            (lambda ()
+              (set-current-module %user-module)
+              (format (current-error-port)
+                      "loading '~a' relative to '~a'...~%"
+                      file source)
+              (primitive-load file))))
+
+         ;; Call the entry point of FILE and print the resulting job sexp.
+         (pretty-print
+          (match ((module-ref %user-module
+                              (if (equal? cuirass? "cuirass")
+                                  'cuirass-jobs
+                                  'hydra-jobs))
+                  store `((guix
+                           . ((file-name . ,source)))))
+            (((names . thunks) ...)
+             (map (lambda (job thunk)
+                    (format (current-error-port) "evaluating '~a'... " job)
+                    (force-output (current-error-port))
+                    (cons job
+                          (assert-valid-job job
+                                            (call-with-time-display thunk))))
+                  names thunks)))
+          port)))))
   ((command _ ...)
    (format (current-error-port) "Usage: ~a FILE [cuirass]
 Evaluate the Hydra or Cuirass jobs defined in FILE.~%"
diff --git a/build-aux/hydra/gnu-system.scm b/build-aux/hydra/gnu-system.scm
index 05d430df0a..775bbd9db2 100644
--- a/build-aux/hydra/gnu-system.scm
+++ b/build-aux/hydra/gnu-system.scm
@@ -23,64 +23,10 @@
 ;;; tool.
 ;;;
 
-(use-modules (system base compile))
-
-(eval-when (expand load eval)
-
-  ;; Pre-load the compiler so we don't end up auto-compiling it.
-  (compile #t)
-
-  ;; Use our very own Guix modules.
-  (set! %fresh-auto-compile #t)
-
-  ;; Ignore .go files except for Guile's.  This is because our checkout in the
-  ;; store has mtime set to the epoch, and thus .go files look newer, even
-  ;; though they may not correspond.  Use 'reverse' so that /gnu/store/…-guile
-  ;; comes before /run/current-system/profile.
-  (set! %load-compiled-path
-    (list
-     (dirname (dirname (search-path (reverse %load-compiled-path)
-                                    "ice-9/boot-9.go")))))
-
-  (and=> (assoc-ref (current-source-location) 'filename)
-         (lambda (file)
-           (let ((dir (canonicalize-path
-                       (string-append (dirname file) "/../.."))))
-             (format (current-error-port) "prepending ~s to the load path~%"
-                     dir)
-             (set! %load-path (cons dir %load-path))))))
-
-(use-modules (guix config)
-             (guix store)
-             (guix grafts)
-             (guix profiles)
-             (guix packages)
-             (guix derivations)
-             (guix monads)
+(use-modules (guix inferior) (guix channels)
+             (guix)
              (guix ui)
-             ((guix licenses) #:select (gpl3+))
-             ((guix utils) #:select (%current-system))
-             ((guix scripts system) #:select (read-operating-system))
-             ((guix scripts pack)
-              #:select (lookup-compressor self-contained-tarball))
-             (gnu bootloader)
-             (gnu bootloader u-boot)
-             (gnu packages)
-             (gnu packages gcc)
-             (gnu packages base)
-             (gnu packages gawk)
-             (gnu packages guile)
-             (gnu packages gettext)
-             (gnu packages compression)
-             (gnu packages multiprecision)
-             (gnu packages make-bootstrap)
-             (gnu packages package-management)
-             (gnu system)
-             (gnu system vm)
-             (gnu system install)
-             (gnu tests)
              (srfi srfi-1)
-             (srfi srfi-26)
              (ice-9 match))
 
 ;; XXX: Debugging hack: since `hydra-eval-guile-jobs' redirects the output
@@ -88,371 +34,45 @@
 (setvbuf (current-error-port) _IOLBF)
 (set-current-output-port (current-error-port))
 
-(define* (package->alist store package system
-                         #:optional (package-derivation package-derivation))
-  "Convert PACKAGE to an alist suitable for Hydra."
-  (parameterize ((%graft? #f))
-    `((derivation . ,(derivation-file-name
-                      (package-derivation store package system
-                                          #:graft? #f)))
-      (description . ,(package-synopsis package))
-      (long-description . ,(package-description package))
-      (license . ,(package-license package))
-      (home-page . ,(package-home-page package))
-      (maintainers . ("bug-guix@gnu.org"))
-      (max-silent-time . ,(or (assoc-ref (package-properties package)
-                                         'max-silent-time)
-                              3600))              ;1 hour by default
-      (timeout . ,(or (assoc-ref (package-properties package) 'timeout)
-                      72000)))))                  ;20 hours by default
-
-(define (package-job store job-name package system)
-  "Return a job called JOB-NAME that builds PACKAGE on SYSTEM."
-  (let ((job-name (symbol-append job-name (string->symbol ".")
-                                 (string->symbol system))))
-    `(,job-name . ,(cut package->alist store package system))))
-
-(define (package-cross-job store job-name package target system)
-  "Return a job called TARGET.JOB-NAME that cross-builds PACKAGE for TARGET on
-SYSTEM."
-  `(,(symbol-append (string->symbol target) (string->symbol ".") job-name
-                    (string->symbol ".") (string->symbol system)) .
-    ,(cute package->alist store package system
-           (lambda* (store package system #:key graft?)
-             (package-cross-derivation store package target system
-                                       #:graft? graft?)))))
-
-(define %core-packages
-  ;; Note: Don't put the '-final' package variants because (1) that's
-  ;; implicit, and (2) they cannot be cross-built (due to the explicit input
-  ;; chain.)
-  (list gcc-4.8 gcc-4.9 gcc-5 glibc binutils
-        gmp mpfr mpc coreutils findutils diffutils patch sed grep
-        gawk gnu-gettext hello guile-2.0 guile-2.2 zlib gzip xz
-        %bootstrap-binaries-tarball
-        %binutils-bootstrap-tarball
-        (%glibc-bootstrap-tarball)
-        %gcc-bootstrap-tarball
-        %guile-bootstrap-tarball
-        %bootstrap-tarballs))
-
-(define %packages-to-cross-build
-  %core-packages)
-
-(define %cross-targets
-  '("mips64el-linux-gnu"
-    "mips64el-linux-gnuabi64"
-    "arm-linux-gnueabihf"
-    "aarch64-linux-gnu"
-    "powerpc-linux-gnu"
-    "i586-pc-gnu"                                 ;aka. GNU/Hurd
-    "i686-w64-mingw32"))
-
-(define %guixsd-supported-systems
-  '("x86_64-linux" "i686-linux" "armhf-linux"))
-
-(define %u-boot-systems
-  '("armhf-linux"))
-
-(define (qemu-jobs store system)
-  "Return a list of jobs that build QEMU images for SYSTEM."
-  (define (->alist drv)
-    `((derivation . ,(derivation-file-name drv))
-      (description . "Stand-alone QEMU image of the GNU system")
-      (long-description . "This is a demo stand-alone QEMU image of the GNU
-system.")
-      (license . ,gpl3+)
-      (home-page . ,%guix-home-page-url)
-      (maintainers . ("bug-guix@gnu.org"))))
-
-  (define (->job name drv)
-    (let ((name (symbol-append name (string->symbol ".")
-                               (string->symbol system))))
-      `(,name . ,(lambda ()
-                   (parameterize ((%graft? #f))
-                     (->alist drv))))))
-
-  (define MiB
-    (expt 2 20))
-
-  (if (member system %guixsd-supported-systems)
-      (if (member system %u-boot-systems)
-          (list (->job 'flash-image
-                       (run-with-store store
-                         (mbegin %store-monad
-                           (set-guile-for-build (default-guile))
-                           (system-disk-image
-                            (operating-system (inherit installation-os)
-                             (bootloader (bootloader-configuration
-                                          (bootloader u-boot-bootloader)
-                                          (target #f))))
-                            #:disk-image-size
-                            (* 1500 MiB))))))
-          (list (->job 'usb-image
-                       (run-with-store store
-                         (mbegin %store-monad
-                           (set-guile-for-build (default-guile))
-                           (system-disk-image installation-os
-                                              #:disk-image-size
-                                              (* 1500 MiB)))))
-                (->job 'iso9660-image
-                       (run-with-store store
-                         (mbegin %store-monad
-                           (set-guile-for-build (default-guile))
-                           (system-disk-image installation-os
-                                              #:file-system-type
-                                              "iso9660"))))))
-      '()))
-
-(define (system-test-jobs store system)
-  "Return a list of jobs for the system tests."
-  (define (test->thunk test)
-    (lambda ()
-      (define drv
-        (run-with-store store
-          (mbegin %store-monad
-            (set-current-system system)
-            (set-grafting #f)
-            (set-guile-for-build (default-guile))
-            (system-test-value test))))
-
-      `((derivation . ,(derivation-file-name drv))
-        (description . ,(format #f "GuixSD '~a' system test"
-                                (system-test-name test)))
-        (long-description . ,(system-test-description test))
-        (license . ,gpl3+)
-        (home-page . ,%guix-home-page-url)
-        (maintainers . ("bug-guix@gnu.org")))))
-
-  (define (->job test)
-    (let ((name (string->symbol
-                 (string-append "test." (system-test-name test)
-                                "." system))))
-      (cons name (test->thunk test))))
-
-  (if (member system %guixsd-supported-systems)
-      (map ->job (all-system-tests))
-      '()))
-
-(define (tarball-jobs store system)
-  "Return Hydra jobs to build the self-contained Guix binary tarball."
-  (define (->alist drv)
-    `((derivation . ,(derivation-file-name drv))
-      (description . "Stand-alone binary Guix tarball")
-      (long-description . "This is a tarball containing binaries of Guix and
-all its dependencies, and ready to be installed on non-GuixSD distributions.")
-      (license . ,gpl3+)
-      (home-page . ,%guix-home-page-url)
-      (maintainers . ("bug-guix@gnu.org"))))
-
-  (define (->job name drv)
-    (let ((name (symbol-append name (string->symbol ".")
-                               (string->symbol system))))
-      `(,name . ,(lambda ()
-                   (parameterize ((%graft? #f))
-                     (->alist drv))))))
-
-  ;; XXX: Add a job for the stable Guix?
-  (list (->job 'binary-tarball
-               (run-with-store store
-                 (mbegin %store-monad
-                   (set-guile-for-build (default-guile))
-                   (>>= (profile-derivation (packages->manifest (list guix)))
-                        (lambda (profile)
-                          (self-contained-tarball "guix-binary" profile
-                                                  #:localstatedir? #t
-                                                  #:compressor
-                                                  (lookup-compressor "xz")))))
-                 #:system system))))
-
-(define job-name
-  ;; Return the name of a package's job.
-  (compose string->symbol
-           (cut package-full-name <> "-")))
-
-(define package->job
-  (let ((base-packages
-         (delete-duplicates
-          (append-map (match-lambda
-                       ((_ package _ ...)
-                        (match (package-transitive-inputs package)
-                          (((_ inputs _ ...) ...)
-                           inputs))))
-                      (%final-inputs)))))
-    (lambda (store package system)
-      "Return a job for PACKAGE on SYSTEM, or #f if this combination is not
-valid."
-      (cond ((member package base-packages)
-             (package-job store (symbol-append 'base. (job-name package))
-                          package system))
-            ((supported-package? package system)
-             (let ((drv (package-derivation store package system
-                                            #:graft? #f)))
-               (and (substitutable-derivation? drv)
-                    (package-job store (job-name package)
-                                 package system))))
-            (else
-             #f)))))
-
-(define (all-packages)
-  "Return the list of packages to build."
-  (define (adjust package result)
-    (cond ((package-replacement package)
-           (cons* package                         ;build both
-                  (package-replacement package)
-                  result))
-          ((package-superseded package)
-           result)                                ;don't build it
-          (else
-           (cons package result))))
-
-  (fold-packages adjust
-                 (fold adjust '()                 ;include base packages
-                       (match (%final-inputs)
-                         (((labels packages _ ...) ...)
-                          packages)))
-                 #:select? (const #t)))           ;include hidden packages
-
-(define (arguments->manifests arguments)
-  "Return the list of manifests extracted from ARGUMENTS."
-  (map (match-lambda
-         ((input-name . relative-path)
-          (let* ((checkout (assq-ref arguments (string->symbol input-name)))
-                 (base (assq-ref checkout 'file-name)))
-            (in-vicinity base relative-path))))
-       (assq-ref arguments 'manifests)))
-
-(define (manifests->packages store manifests)
-  "Return the list of packages found in MANIFESTS."
-  (define (load-manifest manifest)
-    (save-module-excursion
-     (lambda ()
-       (set-current-module (make-user-module '((guix profiles) (gnu))))
-       (primitive-load manifest))))
-
-  (delete-duplicates!
-   (map manifest-entry-item
-        (append-map (compose manifest-entries
-                             load-manifest)
-                    manifests))))
-
-
-;;;
-;;; Hydra entry point.
-;;;
-
 (define (hydra-jobs store arguments)
-  "Return Hydra jobs."
-  (define subset
-    (match (assoc-ref arguments 'subset)
-      ("core" 'core)                              ; only build core packages
-      ("hello" 'hello)                            ; only build hello
-      (((? string?) (? string?) ...) 'list)       ; only build selected list of packages
-      ("manifests" 'manifests)                    ; only build packages in the list of manifests
-      (_ 'all)))                                  ; build everything
-
-  (define systems
-    (match (assoc-ref arguments 'systems)
-      (#f              %hydra-supported-systems)
-      ((lst ...)       lst)
-      ((? string? str) (call-with-input-string str read))))
-
-  (define (cross-jobs system)
-    (define (from-32-to-64? target)
-      ;; Return true if SYSTEM is 32-bit and TARGET is 64-bit.  This hack
-      ;; prevents known-to-fail cross-builds from i686-linux or armhf-linux to
-      ;; mips64el-linux-gnuabi64.
-      (and (or (string-prefix? "i686-" system)
-               (string-prefix? "i586-" system)
-               (string-prefix? "armhf-" system))
-           (string-contains target "64")))    ;x86_64, mips64el, aarch64, etc.
-
-    (define (same? target)
-      ;; Return true if SYSTEM and TARGET are the same thing.  This is so we
-      ;; don't try to cross-compile to 'mips64el-linux-gnu' from
-      ;; 'mips64el-linux'.
-      (or (string-contains target system)
-          (and (string-prefix? "armhf" system)    ;armhf-linux
-               (string-prefix? "arm" target))))   ;arm-linux-gnueabihf
-
-    (define (pointless? target)
-      ;; Return #t if it makes no sense to cross-build to TARGET from SYSTEM.
-      (match system
-        ((or "x86_64-linux" "i686-linux")
-         (if (string-contains target "mingw")
-             (not (string=? "x86_64-linux" system))
-             #f))
-        (_
-         ;; Don't try to cross-compile from non-Intel platforms: this isn't
-         ;; very useful and these are often brittle configurations.
-         #t)))
-
-    (define (either proc1 proc2 proc3)
-      (lambda (x)
-        (or (proc1 x) (proc2 x) (proc3 x))))
-
-    (append-map (lambda (target)
-                  (map (lambda (package)
-                         (package-cross-job store (job-name package)
-                                            package target system))
-                       %packages-to-cross-build))
-                (remove (either from-32-to-64? same? pointless?)
-                        %cross-targets)))
-
-  ;; Turn off grafts.  Grafting is meant to happen on the user's machines.
-  (parameterize ((%graft? #f))
-    ;; Return one job for each package, except bootstrap packages.
-    (append-map (lambda (system)
-                  (format (current-error-port)
-                          "evaluating for '~a' (heap size: ~a MiB)...~%"
-                          system
-                          (round
-                           (/ (assoc-ref (gc-stats) 'heap-size)
-                              (expt 2. 20))))
-                  (invalidate-derivation-caches!)
-                  (case subset
-                    ((all)
-                     ;; Build everything, including replacements.
-                     (let ((all (all-packages))
-                           (job (lambda (package)
-                                  (package->job store package
-                                                system))))
-                       (append (filter-map job all)
-                               (qemu-jobs store system)
-                               (system-test-jobs store system)
-                               (tarball-jobs store system)
-                               (cross-jobs system))))
-                    ((core)
-                     ;; Build core packages only.
-                     (append (map (lambda (package)
-                                    (package-job store (job-name package)
-                                                 package system))
-                                  %core-packages)
-                             (cross-jobs system)))
-                    ((hello)
-                     ;; Build hello package only.
-                     (if (string=? system (%current-system))
-                         (let ((hello (specification->package "hello")))
-                           (list (package-job store (job-name hello) hello system)))
-                         '()))
-                    ((list)
-                     ;; Build selected list of packages only.
-                     (if (string=? system (%current-system))
-                         (let* ((names (assoc-ref arguments 'subset))
-                                (packages (map specification->package names)))
-                           (map (lambda (package)
-                                    (package-job store (job-name package)
-                                                 package system))
-                                  packages))
-                         '()))
-                    ((manifests)
-                     ;; Build packages in the list of manifests.
-                     (let* ((manifests (arguments->manifests arguments))
-                            (packages (manifests->packages store manifests)))
-                       (map (lambda (package)
-                              (package-job store (job-name package)
-                                           package system))
-                            packages)))
-                    (else
-                     (error "unknown subset" subset))))
-                systems)))
+  "Return a list of jobs where each job is a NAME/THUNK pair."
+  (define checkout
+    ;; Extract metadata about the 'guix' checkout.  Its key in ARGUMENTS may
+    ;; vary, so pick up the first one that's neither 'subset' nor 'systems'.
+    (any (match-lambda
+           ((key . value)
+            (and (not (memq key '(systems subset)))
+                 value)))
+         arguments))
+
+  (define commit
+    (assq-ref checkout 'revision))
+
+  (define source
+    (assq-ref checkout 'file-name))
+
+  (define instance
+    (checkout->channel-instance source #:commit commit))
+
+  (define derivation
+    ;; Compute the derivation of Guix for COMMIT.
+    (run-with-store store
+      (channel-instances->derivation (list instance))))
+
+  (show-what-to-build store (list derivation))
+  (build-derivations store (list derivation))
+
+  ;; Open an inferior for the just-built Guix.
+  (let ((inferior (open-inferior (derivation->output-path derivation))))
+    (inferior-eval '(use-modules (gnu ci) (ice-9 match)) inferior)
+
+    (map (match-lambda
+           ((name . fields)
+            ;; Hydra expects a thunk, so here it is.
+            (cons name (lambda () fields))))
+         (inferior-eval-with-store inferior store
+                                   `(lambda (store)
+                                      (map (match-lambda
+                                             ((name . thunk)
+                                              (cons name (thunk))))
+                                           (hydra-jobs store ',arguments)))))))
diff --git a/build-aux/pre-inst-env.in b/build-aux/pre-inst-env.in
index 286a81591c..3efab69e7d 100644
--- a/build-aux/pre-inst-env.in
+++ b/build-aux/pre-inst-env.in
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 # GNU Guix --- Functional package management for GNU
-# Copyright © 2012, 2013, 2014, 2015, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
+# Copyright © 2012, 2013, 2014, 2015, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
 # Copyright © 2017 Eric Bavier <bavier@cray.com>
 #
 # This file is part of GNU Guix.
@@ -45,10 +45,9 @@ export PATH
 # Daemon helpers.
 
 NIX_ROOT_FINDER="$abs_top_builddir/nix/scripts/list-runtime-roots"
-NIX_SUBSTITUTERS="$abs_top_builddir/nix/scripts/substitute"
-NIX_LIBEXEC_DIR="@abs_top_builddir@/nix/scripts" # for 'guix-authenticate'
+NIX_LIBEXEC_DIR="@abs_top_builddir@/nix/scripts" # for 'authenticate', etc.
 
-export NIX_ROOT_FINDER NIX_SUBSTITUTERS NIX_LIBEXEC_DIR
+export NIX_ROOT_FINDER NIX_LIBEXEC_DIR
 
 NIX_BUILD_HOOK="$abs_top_builddir/nix/scripts/offload"
 @BUILD_DAEMON_OFFLOAD_TRUE@export NIX_BUILD_HOOK
diff --git a/build-aux/run-system-tests.scm b/build-aux/run-system-tests.scm
index 953ba3e221..fd1f6653af 100644
--- a/build-aux/run-system-tests.scm
+++ b/build-aux/run-system-tests.scm
@@ -1,5 +1,5 @@
 ;;; GNU Guix --- Functional package management for GNU
-;;; Copyright © 2016, 2018 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2016, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
 ;;;
 ;;; This file is part of GNU Guix.
 ;;;
@@ -30,7 +30,7 @@
 
 (define (built-derivations* drv)
   (lambda (store)
-    (guard (c ((nix-protocol-error? c)
+    (guard (c ((store-protocol-error? c)
                (values #f store)))
       (values (build-derivations store drv) store))))
 
@@ -64,7 +64,7 @@
           (length tests))
 
   (with-store store
-    (with-status-report print-build-event
+    (with-status-verbosity 2
       (run-with-store store
         (mlet* %store-monad ((drv (mapm %store-monad system-test-value tests))
                              (out -> (map derivation->output-path drv)))
diff --git a/build-aux/test-env.in b/build-aux/test-env.in
index aaadcf205b..b1470bb953 100644
--- a/build-aux/test-env.in
+++ b/build-aux/test-env.in
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 # GNU Guix --- Functional package management for GNU
-# Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
+# Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
 #
 # This file is part of GNU Guix.
 #
@@ -51,19 +51,19 @@ then
     NIX_STORE_DIR="`cd "@GUIX_TEST_ROOT@/store"; pwd -P`"
 
     NIX_LOCALSTATE_DIR="@GUIX_TEST_ROOT@/var"
-    NIX_LOG_DIR="@GUIX_TEST_ROOT@/var/log/guix"
-    NIX_DB_DIR="@GUIX_TEST_ROOT@/db"
+    GUIX_LOG_DIRECTORY="@GUIX_TEST_ROOT@/var/log/guix"
+    GUIX_DATABASE_DIRECTORY="@GUIX_TEST_ROOT@/db"
     NIX_ROOT_FINDER="@abs_top_builddir@/nix/scripts/list-runtime-roots"
 
     # Choose a PID-dependent name to allow for parallel builds.  Note
     # that the directory name must be chosen so that the socket's file
     # name is less than 108-char long (the size of `sun_path' in glibc).
     # Currently, in Nix builds, we're at ~106 chars...
-    NIX_STATE_DIR="@GUIX_TEST_ROOT@/var/$$"
+    GUIX_STATE_DIRECTORY="@GUIX_TEST_ROOT@/var/$$"
 
     # We can't exit when we reach the limit, because perhaps the test doesn't
     # actually rely on the daemon, but at least warn.
-    if test "`echo -n "$NIX_STATE_DIR/daemon-socket/socket" | wc -c`" -ge 108
+    if test "`echo -n "$GUIX_STATE_DIRECTORY/daemon-socket/socket" | wc -c`" -ge 108
     then
 	echo "warning: exceeding socket file name limit; test may fail!" >&2
     fi
@@ -82,22 +82,22 @@ then
     fi
 
     # A place to store data of the substituter.
-    GUIX_BINARY_SUBSTITUTE_URL="file://$NIX_STATE_DIR/substituter-data"
-    rm -rf "$NIX_STATE_DIR/substituter-data"
-    mkdir -p "$NIX_STATE_DIR/substituter-data"
+    GUIX_BINARY_SUBSTITUTE_URL="file://$GUIX_STATE_DIRECTORY/substituter-data"
+    rm -rf "$GUIX_STATE_DIRECTORY/substituter-data"
+    mkdir -p "$GUIX_STATE_DIRECTORY/substituter-data"
 
     # For a number of tests, we want to allow unsigned narinfos, for
     # simplicity.
     GUIX_ALLOW_UNAUTHENTICATED_SUBSTITUTES=yes
 
     # Place for the substituter's cache.
-    XDG_CACHE_HOME="$NIX_STATE_DIR/cache-$$"
+    XDG_CACHE_HOME="$GUIX_STATE_DIRECTORY/cache-$$"
 
     # For the (guix import snix) tests.
     NIXPKGS="@NIXPKGS@"
 
     export NIX_IGNORE_SYMLINK_STORE NIX_STORE_DIR		\
-	NIX_LOCALSTATE_DIR NIX_LOG_DIR NIX_STATE_DIR NIX_DB_DIR	\
+	NIX_LOCALSTATE_DIR GUIX_LOG_DIRECTORY GUIX_STATE_DIRECTORY GUIX_DATABASE_DIRECTORY	\
 	NIX_ROOT_FINDER GUIX_BINARY_SUBSTITUTE_URL		\
         GUIX_ALLOW_UNAUTHENTICATED_SUBSTITUTES			\
         GUIX_CONFIGURATION_DIRECTORY XDG_CACHE_HOME NIXPKGS
@@ -109,7 +109,7 @@ then
 	--substitute-urls="$GUIX_BINARY_SUBSTITUTE_URL" &
 
     daemon_pid=$!
-    trap "kill $daemon_pid ; rm -rf $NIX_STATE_DIR" EXIT
+    trap "kill $daemon_pid ; rm -rf $GUIX_STATE_DIRECTORY" EXIT
 
     # The test suite expects the 'guile-bootstrap' package to be available.
     # Normally the Guile bootstrap tarball is downloaded by a fixed-output