[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
13/16: derivations: migrate the rest of the non-rpc-related bindings.
|
From: |
guix-commits |
|
Subject: |
13/16: derivations: migrate the rest of the non-rpc-related bindings. |
|
Date: |
Sat, 20 Apr 2019 17:25:29 -0400 (EDT) |
reepca pushed a commit to branch guile-daemon
in repository guix.
commit 6416860b996e6625133a86fb41125e5ae181991b
Author: Caleb Ristvedt <address@hidden>
Date: Fri Apr 19 12:59:44 2019 -0500
derivations: migrate the rest of the non-rpc-related bindings.
* guix/derivations.scm (&derivation-error, derivation-error?,
derivation-error-derivation, &derivation-missing-output-error,
derivation-missing-output-error?, derivation-missing-output,
coalesce-duplicate-inputs, derivation-name, derivation-path->base16-hash,
derivation-output-names, derivation-hash, derivation-properties,
fixed-output-derivation?, offloadable-derivation?,
substitutable-derivation?, derivation-input<?,
derivation-input-output-paths, derivation-output-paths,
derivation->output-path, derivation->output-paths,
derivation-path->output-path, derivation-path->output-paths,
derivation-prerequisites, derivation/masked-inputs,
invalidate-derivation-caches!): Moved to (guix store derivations), any of
them that were exported are now re-exported.
* guix/store/derivations.scm: above-mentioned definitions moved here.
* guix/store.scm (&store-error, store-error?): Moved to (guix store files)
and
re-exported.
(%store-prefix): re-exported.
* guix/store/files.scm (&store-error, store-error?): Moved here and
exported.
(%store-prefix): exported.
---
guix/derivations.scm | 261 ++++++---------------------------------------
guix/store.scm | 7 +-
guix/store/derivations.scm | 252 ++++++++++++++++++++++++++++++++++++++++++-
guix/store/files.scm | 11 +-
4 files changed, 291 insertions(+), 240 deletions(-)
diff --git a/guix/derivations.scm b/guix/derivations.scm
index e87cd24..3bd8db4 100644
--- a/guix/derivations.scm
+++ b/guix/derivations.scm
@@ -40,34 +40,13 @@
#:use-module (guix records)
#:use-module (guix sets)
#:use-module (guix store derivations)
- #:export (derivation-input-output-paths
- derivation-prerequisites
- derivation-prerequisites-to-build
+ #:export (derivation-prerequisites-to-build
valid-derivation-input?
- &derivation-error
- derivation-error?
- derivation-error-derivation
- &derivation-missing-output-error
- derivation-missing-output-error?
- derivation-missing-output
-
- derivation-name
- derivation-output-names
- fixed-output-derivation?
- offloadable-derivation?
- substitutable-derivation?
substitution-oracle
- derivation-hash
- derivation-properties
- derivation->output-path
- derivation->output-paths
- derivation-path->output-path
- derivation-path->output-paths
derivation
raw-derivation
- invalidate-derivation-caches!
map-derivation
@@ -84,6 +63,15 @@
;; Re-export it from here for backward compatibility.
#:re-export (%guile-for-build
+
+ &derivation-error
+ derivation-error?
+ derivation-error-derivation
+
+ &derivation-missing-output-error
+ derivation-missing-output-error?
+ derivation-missing-output
+
<derivation>
derivation?
derivation-outputs
@@ -107,54 +95,28 @@
derivation-input-path
derivation-input-sub-derivations
+ derivation-name
+ derivation-output-names
+ derivation-hash
+ derivation-properties
+ fixed-output-derivation?
+ offloadable-derivation?
+ substitutable-derivation?
+
+ derivation-input<?
+ derivation-input-output-paths
+ derivation->output-path
+ derivation->output-paths
+ derivation-path->output-path
+ derivation-path->output-paths
+
+ derivation-prerequisites
+
read-derivation
read-derivation-from-file
- write-derivation))
-
-;;;
-;;; Error conditions.
-;;;
+ write-derivation
+ invalidate-derivation-caches!))
-(define-condition-type &derivation-error &store-error
- derivation-error?
- (derivation derivation-error-derivation))
-
-(define-condition-type &derivation-missing-output-error &derivation-error
- derivation-missing-output-error?
- (output derivation-missing-output))
-
-(define (derivation-name drv)
- "Return the base name of DRV."
- (let ((base (store-path-package-name (derivation-file-name drv))))
- (string-drop-right base 4)))
-
-(define (derivation-output-names drv)
- "Return the names of the outputs of DRV."
- (match (derivation-outputs drv)
- (((names . _) ...)
- names)))
-
-(define (fixed-output-derivation? drv)
- "Return #t if DRV is a fixed-output derivation, such as the result of a
-download with a fixed hash (aka. `fetchurl')."
- (match drv
- (($ <derivation>
- (("out" . ($ <derivation-output> _ (? symbol?) (? bytevector?)))))
- #t)
- (_ #f)))
-
-(define (derivation-input<? input1 input2)
- "Compare INPUT1 and INPUT2, two <derivation-input>."
- (string<? (derivation-input-path input1)
- (derivation-input-path input2)))
-
-(define (derivation-input-output-paths input)
- "Return the list of output paths corresponding to INPUT, a
-<derivation-input>."
- (match input
- (($ <derivation-input> path sub-drvs)
- (map (cut derivation-path->output-path path <>)
- sub-drvs))))
(define (valid-derivation-input? store input)
"Return true if INPUT is valid--i.e., if all the outputs it requests are in
@@ -162,74 +124,6 @@ the store."
(every (cut valid-path? store <>)
(derivation-input-output-paths input)))
-(define (coalesce-duplicate-inputs inputs)
- "Return a list of inputs, such that when INPUTS contains the same DRV twice,
-they are coalesced, with their sub-derivations merged. This is needed because
-Nix itself keeps only one of them."
- (fold (lambda (input result)
- (match input
- (($ <derivation-input> path sub-drvs)
- ;; XXX: quadratic
- (match (find (match-lambda
- (($ <derivation-input> p s)
- (string=? p path)))
- result)
- (#f
- (cons input result))
- ((and dup ($ <derivation-input> _ sub-drvs2))
- ;; Merge DUP with INPUT.
- (let ((sub-drvs (delete-duplicates
- (append sub-drvs sub-drvs2))))
- (cons (make-derivation-input path
- (sort sub-drvs string<?))
- (delq dup result))))))))
- '()
- inputs))
-
-(define* (derivation-prerequisites drv #:optional (cut? (const #f)))
- "Return the list of derivation-inputs required to build DRV, recursively.
-
-CUT? is a predicate that is passed a derivation-input and returns true to
-eliminate the given input and its dependencies from the search. An example of
-such a predicate is 'valid-derivation-input?'; when it is used as CUT?, the
-result is the set of prerequisites of DRV not already in valid."
- (let loop ((drv drv)
- (result '())
- (input-set (set)))
- (let ((inputs (remove (lambda (input)
- (or (set-contains? input-set input)
- (cut? input)))
- (derivation-inputs drv))))
- (fold2 loop
- (append inputs result)
- (fold set-insert input-set inputs)
- (map (lambda (i)
- (read-derivation-from-file (derivation-input-path i)))
- inputs)))))
-
-(define (offloadable-derivation? drv)
- "Return true if DRV can be offloaded, false otherwise."
- (match (assoc "preferLocalBuild"
- (derivation-builder-environment-vars drv))
- (("preferLocalBuild" . "1") #f)
- (_ #t)))
-
-(define (substitutable-derivation? drv)
- "Return #t if DRV can be substituted."
- (match (assoc "allowSubstitutes"
- (derivation-builder-environment-vars drv))
- (("allowSubstitutes" . value)
- (string=? value "1"))
- (_ #t)))
-
-(define (derivation-output-paths drv sub-drvs)
- "Return the output paths of outputs SUB-DRVS of DRV."
- (match drv
- (($ <derivation> outputs)
- (map (lambda (sub-drv)
- (derivation-output-path (assoc-ref outputs sub-drv)))
- sub-drvs))))
-
(define* (substitution-oracle store drv
#:key (mode (build-mode normal)))
"Return a one-argument procedure that, when passed a store file name,
@@ -367,91 +261,13 @@ one-argument procedure similar to that returned by
'substitution-oracle'."
inputs)
(map derivation-input-sub-derivations inputs)))))))
-(define* (derivation->output-path drv #:optional (output "out"))
- "Return the store path of its output OUTPUT. Raise a
-'&derivation-missing-output-error' condition if OUTPUT is not an output of
-DRV."
- (let ((output* (assoc-ref (derivation-outputs drv) output)))
- (if output*
- (derivation-output-path output*)
- (raise (condition (&derivation-missing-output-error
- (derivation drv)
- (output output)))))))
-
-(define (derivation->output-paths drv)
- "Return the list of name/path pairs of the outputs of DRV."
- (map (match-lambda
- ((name . output)
- (cons name (derivation-output-path output))))
- (derivation-outputs drv)))
-
-(define derivation-path->output-path
- ;; This procedure is called frequently, so memoize it.
- (let ((memoized (mlambda (path output)
- (derivation->output-path (read-derivation-from-file path)
- output))))
- (lambda* (path #:optional (output "out"))
- "Read the derivation from PATH (`/gnu/store/xxx.drv'), and return the
store
-path of its output OUTPUT."
- (memoized path output))))
-
-(define (derivation-path->output-paths path)
- "Read the derivation from PATH (`/gnu/store/xxx.drv'), and return the
-list of name/path pairs of its outputs."
- (derivation->output-paths (read-derivation-from-file path)))
+
;;;
;;; Derivation primitive.
;;;
-(define derivation-path->base16-hash
- (mlambda (file)
- "Return a string containing the base16 representation of the hash of the
-derivation at FILE."
- (bytevector->base16-string
- (derivation-hash (read-derivation-from-file file)))))
-
-(define (derivation/masked-inputs drv)
- "Assuming DRV is a regular derivation (not fixed-output), replace the file
-name of each input with that input's hash."
- (match drv
- (($ <derivation> outputs inputs sources
- system builder args env-vars)
- (let ((inputs (map (match-lambda
- (($ <derivation-input> path sub-drvs)
- (let ((hash (derivation-path->base16-hash path)))
- (make-derivation-input hash sub-drvs))))
- inputs)))
- (make-derivation outputs
- (sort (coalesce-duplicate-inputs inputs)
- derivation-input<?)
- sources
- system builder args env-vars
- #f)))))
-
-(define derivation-hash ; `hashDerivationModulo' in derivations.cc
- (lambda (drv)
- "Return the hash of DRV, modulo its fixed-output inputs, as a bytevector."
- (match drv
- (($ <derivation> ((_ . ($ <derivation-output> path
- (? symbol? hash-algo) (?
bytevector? hash)
- (? boolean? recursive?)))))
- ;; A fixed-output derivation.
- (sha256
- (string->utf8
- (string-append "fixed:out:"
- (if recursive? "r:" "")
- (symbol->string hash-algo)
- ":" (bytevector->base16-string hash)
- ":" path))))
- (_
-
- ;; XXX: At this point this remains faster than `port-sha256', because
- ;; the SHA256 port's `write' method gets called for every single
- ;; character.
- (sha256 (derivation->bytevector (derivation/masked-inputs drv)))))))
-
(define* (derivation store name builder args
#:key
(system (%current-system)) (env-vars '())
@@ -629,23 +445,6 @@ derivation. It is kept as-is, uninterpreted, in the
derivation."
(hash-set! %derivation-cache file drv*)
drv*)))
-(define (invalidate-derivation-caches!)
- "Invalidate internal derivation caches. This is mostly useful for
-long-running processes that know what they're doing. Use with care!"
- ;; Typically this is meant to be used by Cuirass and Hydra, which can clear
- ;; caches when they start evaluating packages for another architecture.
- (invalidate-memoization! derivation->bytevector)
- (invalidate-memoization! derivation-path->base16-hash)
- (hash-clear! %derivation-cache))
-
-(define derivation-properties
- (mlambdaq (drv)
- "Return the property alist associated with DRV."
- (match (assoc "guix properties"
- (derivation-builder-environment-vars drv))
- ((_ . str) (call-with-input-string str read))
- (#f '()))))
-
(define* (map-derivation store drv mapping
#:key (system (%current-system)))
"Given MAPPING, a list of pairs of derivations, return a derivation based on
diff --git a/guix/store.scm b/guix/store.scm
index 0dd1f18..bd43b65 100644
--- a/guix/store.scm
+++ b/guix/store.scm
@@ -69,7 +69,6 @@
current-store-protocol-version ;for internal use
mcached
- &store-error store-error?
&store-connection-error store-connection-error?
store-connection-error-file
store-connection-error-code
@@ -165,7 +164,8 @@
interned-file-tree
log-file)
- #:re-export (%store-prefix
+ #:re-export (&store-error store-error?
+ %store-prefix
store-path
output-path
fixed-output-path
@@ -390,9 +390,6 @@
(define-deprecated/alias nix-server-socket store-connection-socket)
-(define-condition-type &store-error &error
- store-error?)
-
(define-condition-type &store-connection-error &store-error
store-connection-error?
(file store-connection-error-file)
diff --git a/guix/store/derivations.scm b/guix/store/derivations.scm
index 583c7b4..dbf8bde 100644
--- a/guix/store/derivations.scm
+++ b/guix/store/derivations.scm
@@ -22,13 +22,28 @@
(define-module (guix store derivations)
#:use-module (ice-9 match)
#:use-module (rnrs io ports)
+ #:use-module (rnrs bytevectors)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-9)
#:use-module (srfi srfi-9 gnu)
#:use-module (srfi srfi-26)
+ #:use-module (srfi srfi-34)
+ #:use-module (srfi srfi-35)
+ #:use-module (gcrypt hash)
#:use-module (guix base16)
+ #:use-module (guix combinators)
#:use-module (guix memoization)
- #:export (<derivation>
+ #:use-module (guix sets)
+ #:use-module (guix store files)
+ #:export (&derivation-error
+ derivation-error?
+ derivation-error-derivation
+
+ &derivation-missing-output-error
+ derivation-missing-output-error?
+ derivation-missing-output
+
+ <derivation>
make-derivation
derivation?
derivation-outputs
@@ -53,12 +68,34 @@
derivation-input?
derivation-input-path
derivation-input-sub-derivations
+ coalesce-duplicate-inputs
+
+ derivation-name
+ derivation-path->base16-hash
+ derivation-output-names
+ derivation-hash
+ derivation-properties
+ fixed-output-derivation?
+ offloadable-derivation?
+ substitutable-derivation?
+
+ derivation-input<?
+ derivation-input-output-paths
+ derivation-output-paths
+ derivation->output-path
+ derivation->output-paths
+ derivation-path->output-path
+ derivation-path->output-paths
+
+ derivation-prerequisites
+ derivation/masked-inputs
read-derivation
read-derivation-from-file
derivation->bytevector
%derivation-cache
- write-derivation))
+ write-derivation
+ invalidate-derivation-caches!))
;;;
;;; Nix derivations, as implemented in Nix's `derivations.cc'.
@@ -102,6 +139,217 @@
(derivation-outputs drv)))
(number->string (object-address drv) 16))))
+;;;
+;;; Error conditions.
+;;;
+
+(define-condition-type &derivation-error &store-error
+ derivation-error?
+ (derivation derivation-error-derivation))
+
+(define-condition-type &derivation-missing-output-error &derivation-error
+ derivation-missing-output-error?
+ (output derivation-missing-output))
+
+
+(define (derivation-name drv)
+ "Return the base name of DRV."
+ (let ((base (store-path-package-name (derivation-file-name drv))))
+ (string-drop-right base 4)))
+
+(define (derivation-output-names drv)
+ "Return the names of the outputs of DRV."
+ (match (derivation-outputs drv)
+ (((names . _) ...)
+ names)))
+
+(define (fixed-output-derivation? drv)
+ "Return #t if DRV is a fixed-output derivation, such as the result of a
+download with a fixed hash (aka. `fetchurl')."
+ (match drv
+ (($ <derivation>
+ (("out" . ($ <derivation-output> _ (? symbol?) (? bytevector?)))))
+ #t)
+ (_ #f)))
+
+(define (derivation-input<? input1 input2)
+ "Compare INPUT1 and INPUT2, two <derivation-input>."
+ (string<? (derivation-input-path input1)
+ (derivation-input-path input2)))
+
+(define (coalesce-duplicate-inputs inputs)
+ "Return a list of inputs, such that when INPUTS contains the same DRV twice,
+they are coalesced, with their sub-derivations merged. This is needed because
+Nix itself keeps only one of them."
+ (fold (lambda (input result)
+ (match input
+ (($ <derivation-input> path sub-drvs)
+ ;; XXX: quadratic
+ (match (find (match-lambda
+ (($ <derivation-input> p s)
+ (string=? p path)))
+ result)
+ (#f
+ (cons input result))
+ ((and dup ($ <derivation-input> _ sub-drvs2))
+ ;; Merge DUP with INPUT.
+ (let ((sub-drvs (delete-duplicates
+ (append sub-drvs sub-drvs2))))
+ (cons (make-derivation-input path
+ (sort sub-drvs string<?))
+ (delq dup result))))))))
+ '()
+ inputs))
+
+(define* (derivation-prerequisites drv #:optional (cut? (const #f)))
+ "Return the list of derivation-inputs required to build DRV, recursively.
+
+CUT? is a predicate that is passed a derivation-input and returns true to
+eliminate the given input and its dependencies from the search. An example of
+such a predicate is 'valid-derivation-input?'; when it is used as CUT?, the
+result is the set of prerequisites of DRV not already in valid."
+ (let loop ((drv drv)
+ (result '())
+ (input-set (set)))
+ (let ((inputs (remove (lambda (input)
+ (or (set-contains? input-set input)
+ (cut? input)))
+ (derivation-inputs drv))))
+ (fold2 loop
+ (append inputs result)
+ (fold set-insert input-set inputs)
+ (map (lambda (i)
+ (read-derivation-from-file (derivation-input-path i)))
+ inputs)))))
+
+(define (offloadable-derivation? drv)
+ "Return true if DRV can be offloaded, false otherwise."
+ (match (assoc "preferLocalBuild"
+ (derivation-builder-environment-vars drv))
+ (("preferLocalBuild" . "1") #f)
+ (_ #t)))
+
+(define (substitutable-derivation? drv)
+ "Return #t if DRV can be substituted."
+ (match (assoc "allowSubstitutes"
+ (derivation-builder-environment-vars drv))
+ (("allowSubstitutes" . value)
+ (string=? value "1"))
+ (_ #t)))
+
+(define (derivation-output-paths drv sub-drvs)
+ "Return the output paths of outputs SUB-DRVS of DRV."
+ (match drv
+ (($ <derivation> outputs)
+ (map (lambda (sub-drv)
+ (derivation-output-path (assoc-ref outputs sub-drv)))
+ sub-drvs))))
+
+(define derivation-path->base16-hash
+ (mlambda (file)
+ "Return a string containing the base16 representation of the hash of the
+derivation at FILE."
+ (bytevector->base16-string
+ (derivation-hash (read-derivation-from-file file)))))
+
+(define (derivation/masked-inputs drv)
+ "Assuming DRV is a regular derivation (not fixed-output), replace the file
+name of each input with that input's hash."
+ (match drv
+ (($ <derivation> outputs inputs sources
+ system builder args env-vars)
+ (let ((inputs (map (match-lambda
+ (($ <derivation-input> path sub-drvs)
+ (let ((hash (derivation-path->base16-hash path)))
+ (make-derivation-input hash sub-drvs))))
+ inputs)))
+ (make-derivation outputs
+ (sort (coalesce-duplicate-inputs inputs)
+ derivation-input<?)
+ sources
+ system builder args env-vars
+ #f)))))
+
+(define derivation-hash ; `hashDerivationModulo' in derivations.cc
+ (lambda (drv)
+ "Return the hash of DRV, modulo its fixed-output inputs, as a bytevector."
+ (match drv
+ (($ <derivation> ((_ . ($ <derivation-output> path
+ (? symbol? hash-algo) (?
bytevector? hash)
+ (? boolean? recursive?)))))
+ ;; A fixed-output derivation.
+ (sha256
+ (string->utf8
+ (string-append "fixed:out:"
+ (if recursive? "r:" "")
+ (symbol->string hash-algo)
+ ":" (bytevector->base16-string hash)
+ ":" path))))
+ (_
+
+ ;; XXX: At this point this remains faster than `port-sha256', because
+ ;; the SHA256 port's `write' method gets called for every single
+ ;; character.
+ (sha256 (derivation->bytevector (derivation/masked-inputs drv)))))))
+
+(define (invalidate-derivation-caches!)
+ "Invalidate internal derivation caches. This is mostly useful for
+long-running processes that know what they're doing. Use with care!"
+ ;; Typically this is meant to be used by Cuirass and Hydra, which can clear
+ ;; caches when they start evaluating packages for another architecture.
+ (invalidate-memoization! derivation->bytevector)
+ (invalidate-memoization! derivation-path->base16-hash)
+ (hash-clear! %derivation-cache))
+
+(define derivation-properties
+ (mlambdaq (drv)
+ "Return the property alist associated with DRV."
+ (match (assoc "guix properties"
+ (derivation-builder-environment-vars drv))
+ ((_ . str) (call-with-input-string str read))
+ (#f '()))))
+
+(define (derivation-input-output-paths input)
+ "Return the list of output paths corresponding to INPUT, a
+<derivation-input>."
+ (match input
+ (($ <derivation-input> path sub-drvs)
+ (map (cut derivation-path->output-path path <>)
+ sub-drvs))))
+
+(define* (derivation->output-path drv #:optional (output "out"))
+ "Return the store path of its output OUTPUT. Raise a
+'&derivation-missing-output-error' condition if OUTPUT is not an output of
+DRV."
+ (let ((output* (assoc-ref (derivation-outputs drv) output)))
+ (if output*
+ (derivation-output-path output*)
+ (raise (condition (&derivation-missing-output-error
+ (derivation drv)
+ (output output)))))))
+
+(define (derivation->output-paths drv)
+ "Return the list of name/path pairs of the outputs of DRV."
+ (map (match-lambda
+ ((name . output)
+ (cons name (derivation-output-path output))))
+ (derivation-outputs drv)))
+
+(define derivation-path->output-path
+ ;; This procedure is called frequently, so memoize it.
+ (let ((memoized (mlambda (path output)
+ (derivation->output-path (read-derivation-from-file path)
+ output))))
+ (lambda* (path #:optional (output "out"))
+ "Read the derivation from PATH (`/gnu/store/xxx.drv'), and return the
store
+path of its output OUTPUT."
+ (memoized path output))))
+
+(define (derivation-path->output-paths path)
+ "Read the derivation from PATH (`/gnu/store/xxx.drv'), and return the
+list of name/path pairs of its outputs."
+ (derivation->output-paths (read-derivation-from-file path)))
+
(define (read-derivation drv-port)
"Read the derivation from DRV-PORT and return the corresponding <derivation>
object. Most of the time you'll want to use 'read-derivation-from-file',
diff --git a/guix/store/files.scm b/guix/store/files.scm
index 06ed039..290a602 100644
--- a/guix/store/files.scm
+++ b/guix/store/files.scm
@@ -22,12 +22,15 @@
#:use-module (ice-9 regex)
#:use-module (rnrs bytevectors)
#:use-module (srfi srfi-26)
+ #:use-module (srfi srfi-35)
#:use-module (gcrypt hash)
#:use-module (guix base32)
#:use-module (guix base16)
#:use-module (guix config)
#:use-module (guix memoization)
- #:export (%store-prefix
+ #:export (&store-error
+ store-error?
+ %store-prefix
store-path
output-path
fixed-output-path
@@ -38,7 +41,11 @@
store-path-hash-part
direct-store-path
derivation-log-file
- log-file))
+ log-file
+ compressed-hash))
+
+(define-condition-type &store-error &error
+ store-error?)
;;;
;;; Store paths.
- branch guile-daemon created (now b1ff580), guix-commits, 2019/04/20
- 03/16: guix: store: Register derivation outputs., guix-commits, 2019/04/20
- 08/16: linux-container: don't include /dev/ptmx or /dev/pts from host., guix-commits, 2019/04/20
- 11/16: syscalls: add missing pieces for derivation build environment, guix-commits, 2019/04/20
- 10/16: gnu: linux-container: Make it more suitable for derivation-building., guix-commits, 2019/04/20
- 04/16: guix/store/build-derivations.scm: new module., guix-commits, 2019/04/20
- 05/16: linux-container: new use-output argument., guix-commits, 2019/04/20
- 12/16: config: add variables for more directories, %impersonate-linux-2.6?, guix-commits, 2019/04/20
- 14/16: build-derivations: scan for hashes, not full paths., guix-commits, 2019/04/20
- 13/16: derivations: migrate the rest of the non-rpc-related bindings.,
guix-commits <=
- 01/16: gnu: address@hidden: Honor NIX_STORE., guix-commits, 2019/04/20
- 06/16: build-derivations: use call-with-container, guix-commits, 2019/04/20
- 09/16: build-derivations: Leaked environment variables more robust., guix-commits, 2019/04/20
- 15/16: build-derivations: Adapt docstrings to fit style., guix-commits, 2019/04/20
- 07/16: build-derivations: initial build-group support, guix-commits, 2019/04/20
- 02/16: guix: split (guix store) and (guix derivations)., guix-commits, 2019/04/20
- 16/16: build-derivations: move environment code to (guix store environment), guix-commits, 2019/04/20