[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
01/01: DRAFT grafts: Graft recursively.
|
From: |
Ludovic Courtès |
|
Subject: |
01/01: DRAFT grafts: Graft recursively. |
|
Date: |
Sun, 28 Feb 2016 23:03:34 +0000 |
civodul pushed a commit to branch wip-recursive-grafts
in repository guix.
commit aabc5847008cd28b57bf13d7b708c7a8d70a300e
Author: Ludovic Courtès <address@hidden>
Date: Sat Feb 27 23:06:50 2016 +0100
DRAFT grafts: Graft recursively.
Fixes <http://bugs.gnu.org/22139>.
* guix/grafts.scm (graft-derivation): Rename to...
(graft-derivation/shallow): ... this.
(graft-origin-file-name, item->deriver, non-self-references)
(cumulative-grafts, graft-derivation): New procedures
* tests/grafts.scm ("graft-derivation, grafted item is a direct
dependency"): Clarify title. Use 'grafted' instead of 'graft' to refer
to the grafted derivation.
("graft-derivation, grafted item is an indirect dependency",
"cumulative-grafts, no dependencies on grafted output"): New tests.
* guix/packages.scm (input-graft): Change to take a package instead of
an input.
(input-cross-graft): Likewise.
(fold-bag-dependencies): New procedure.
(bag-grafts): Rewrite in terms of 'fold-bag-dependencies'.
* doc/guix.texi (Security Updates): Mention run-time dependencies and
recursive grafting.
---
doc/guix.texi | 9 +++-
guix/grafts.scm | 122 +++++++++++++++++++++++++++++++++++++++++++++++++---
guix/packages.scm | 125 ++++++++++++++++++++++++++++++++++------------------
tests/grafts.scm | 89 +++++++++++++++++++++++++++++++------
4 files changed, 278 insertions(+), 67 deletions(-)
diff --git a/doc/guix.texi b/doc/guix.texi
index 4c9a91b..5e62703 100644
--- a/doc/guix.texi
+++ b/doc/guix.texi
@@ -10244,11 +10244,14 @@ Packages}). Then, the original package definition is
augmented with a
(replacement bash-fixed)))
@end example
-From there on, any package depending directly or indirectly on Bash that
-is installed will automatically be ``rewritten'' to refer to
+From there on, any package depending directly or indirectly on Bash---as
+reported by @command{guix gc --requisites} (@pxref{Invoking guix
+gc})---that is installed is automatically ``rewritten'' to refer to
@var{bash-fixed} instead of @var{bash}. This grafting process takes
time proportional to the size of the package, but expect less than a
-minute for an ``average'' package on a recent machine.
+minute for an ``average'' package on a recent machine. Grafting is
+recursive: when an indirect dependency requires grafting, then grafting
+``propagates'' up to the package that the user is installing.
Currently, the graft and the package it replaces (@var{bash-fixed} and
@var{bash} in the example above) must have the exact same @code{name}
diff --git a/guix/grafts.scm b/guix/grafts.scm
index ea53959..6769e89 100644
--- a/guix/grafts.scm
+++ b/guix/grafts.scm
@@ -17,11 +17,14 @@
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (guix grafts)
+ #:use-module (guix store)
+ #:use-module (guix monads)
#:use-module (guix records)
#:use-module (guix derivations)
#:use-module ((guix utils) #:select (%current-system))
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-9 gnu)
+ #:use-module (srfi srfi-11)
#:use-module (srfi srfi-26)
#:use-module (ice-9 match)
#:export (graft?
@@ -32,6 +35,7 @@
graft-replacement-output
graft-derivation
+ cumulative-grafts
%graft?
set-grafting))
@@ -61,13 +65,22 @@
(set-record-type-printer! <graft> write-graft)
-(define* (graft-derivation store drv grafts
- #:key
- (name (derivation-name drv))
- (guile (%guile-for-build))
- (system (%current-system)))
+(define (graft-origin-file-name graft)
+ "Return the output file name of the origin of GRAFT."
+ (match graft
+ (($ <graft> (? derivation? origin) output)
+ (derivation->output-path origin output))
+ (($ <graft> (? string? item))
+ item)))
+
+(define* (graft-derivation/shallow store drv grafts
+ #:key
+ (name (derivation-name drv))
+ (guile (%guile-for-build))
+ (system (%current-system)))
"Return a derivation called NAME, based on DRV but with all the GRAFTS
-applied."
+applied. This procedure performs \"shallow\" grafting in that GRAFTS are not
+recursively applied to dependencies of DRV."
;; XXX: Someday rewrite using gexps.
(define mapping
;; List of store item pairs.
@@ -134,6 +147,103 @@ applied."
#:outputs output-names
#:local-build? #t)))))
+;; (define (input->derivation input)
+;; (call-with-input-file (derivation-input-path input)
+;; read-derivation))
+
+;; (define (directly-applicable? drv grafts)
+;; "Return #t if at least one of GRAFTS corresponds to a direct input of
DRV."
+;; (let ((inputs (map input->derivation (derivation-inputs drv)))
+;; (sources (derivation-sources drv)))
+;; (find (lambda (graft)
+;; (match (graft-origin graft)
+;; ((? derivation? drv)
+;; (member drv inputs))
+;; ((? string? item)
+;; (member item sources))))
+;; grafts)))
+
+(define (item->deriver store item)
+ "Return two values: the derivation that led to ITEM (a store item), and the
+name of the output of that derivation ITEM corresponds to (for example
+\"out\"). When ITEM has no deriver, for instance because it is a plain file,
+#f and #f are returned."
+ (match (valid-derivers store item)
+ (() ;ITEM is a plain file
+ (values #f #f))
+ ((drv-file _ ...)
+ (let ((drv (call-with-input-file drv-file read-derivation)))
+ (values drv
+ (any (match-lambda
+ ((name . path)
+ (and (string=? item path) name)))
+ (derivation->output-paths drv)))))))
+
+(define (non-self-references store drv outputs)
+ "Return the list of references of the OUTPUTS of DRV, excluding self
+references."
+ (let ((refs (append-map (lambda (output)
+ (references store
+ (derivation->output-path drv output)))
+ outputs))
+ (self (match (derivation->output-paths drv)
+ (((names . items) ...)
+ items))))
+ (remove (cut member <> self) refs)))
+
+(define* (cumulative-grafts store drv grafts
+ #:key
+ (outputs (derivation-output-names drv))
+ (guile (%guile-for-build))
+ (system (%current-system)))
+ "Augment GRAFTS with additional grafts resulting from the application of
+GRAFTS to the dependencies of DRV. Return the resulting list of grafts."
+ (define (dependency-grafts item)
+ (let-values (((drv output) (item->deriver store item)))
+ (if drv
+ (cumulative-grafts store drv grafts
+ #:outputs (list output)
+ #:guile guile
+ #:system system)
+ grafts)))
+
+ ;; TODO: Memoize.
+ (match (non-self-references store drv outputs)
+ (() ;no dependencies
+ grafts)
+ (deps ;one or more dependencies
+ (let* ((grafts (delete-duplicates (append-map dependency-grafts deps)
+ eq?))
+ (origins (map graft-origin-file-name grafts)))
+ (if (pk 'applicable? drv grafts
+ (find (cut member <> deps) origins))
+ (let ((new (graft-derivation/shallow store drv grafts
+ #:guile guile
+ #:system system)))
+ (cons (graft (origin drv) (replacement new))
+ grafts))
+ grafts)))))
+
+(define* (graft-derivation store drv grafts
+ #:key (guile (%guile-for-build))
+ (system (%current-system)))
+ "Applied GRAFTS to DRV and all its dependencies, recursively. That is, if
+GRAFTS apply only indirectly to DRV, graft the dependencies of DRV, and graft
+DRV itself to refer to those grafted dependencies."
+
+ ;; First, we need to build the ungrafted DRV so we can query its run-time
+ ;; dependencies in 'cumulative-grafts'.
+ (build-derivations store (list drv))
+
+ (match (pk 'cumul (cumulative-grafts store drv (pk 'initgrafts grafts)
+ #:guile guile #:system system))
+ ((first . rest)
+ ;; If FIRST is not a graft for DRV, it means that GRAFTS are not
+ ;; applicable to DRV and nothing needs to be done.
+ (if (equal? drv (graft-origin first))
+ (graft-replacement first)
+ drv))))
+
;; The following might feel more at home in (guix packages) but since (guix
;; gexp), which is a lower level, needs them, we put them here.
diff --git a/guix/packages.scm b/guix/packages.scm
index f6afaeb..344b79e 100644
--- a/guix/packages.scm
+++ b/guix/packages.scm
@@ -30,6 +30,7 @@
#:use-module (guix build-system)
#:use-module (guix search-paths)
#:use-module (guix gexp)
+ #:use-module (guix sets)
#:use-module (ice-9 match)
#:use-module (ice-9 vlist)
#:use-module (srfi srfi-1)
@@ -831,30 +832,25 @@ and return it."
(package package))))))))))
(define (input-graft store system)
- "Return a procedure that, given an input referring to a package with a
-graft, returns a pair with the original derivation and the graft's derivation,
-and returns #f for other inputs."
+ "Return a procedure that, given a package with a graft, returns a graft, and
+#f otherwise."
(match-lambda
- ((label (? package? package) sub-drv ...)
- (let ((replacement (package-replacement package)))
- (and replacement
- (let ((orig (package-derivation store package system
- #:graft? #f))
- (new (package-derivation store replacement system)))
- (graft
- (origin orig)
- (replacement new)
- (origin-output (match sub-drv
- (() "out")
- ((output) output)))
- (replacement-output origin-output))))))
- (x
- #f)))
+ ((? package? package)
+ (let ((replacement (package-replacement package)))
+ (and replacement
+ (let ((orig (package-derivation store package system
+ #:graft? #f))
+ (new (package-derivation store replacement system)))
+ (graft
+ (origin orig)
+ (replacement new))))))
+ (x
+ #f)))
(define (input-cross-graft store target system)
"Same as 'input-graft', but for cross-compilation inputs."
(match-lambda
- ((label (? package? package) sub-drv ...)
+ ((? package? package)
(let ((replacement (package-replacement package)))
(and replacement
(let ((orig (package-cross-derivation store package target system
@@ -863,34 +859,74 @@ and returns #f for other inputs."
target system)))
(graft
(origin orig)
- (replacement new)
- (origin-output (match sub-drv
- (() "out")
- ((output) output)))
- (replacement-output origin-output))))))
+ (replacement new))))))
(_
#f)))
-(define* (bag-grafts store bag)
- "Return the list of grafts applicable to BAG. Each graft is a <graft>
-record."
- (let ((target (bag-target bag))
- (system (bag-system bag)))
- (define native-grafts
- (filter-map (input-graft store system)
- (append (bag-transitive-build-inputs bag)
- (bag-transitive-target-inputs bag)
- (if target
- '()
- (bag-transitive-host-inputs bag)))))
-
- (define target-grafts
- (if target
- (filter-map (input-cross-graft store target system)
- (bag-transitive-host-inputs bag))
- '()))
+(define* (fold-bag-dependencies proc seed bag
+ #:key (native? #t))
+ "Fold PROC over the packages BAG depends on. If NATIVE? is true, restrict
+to native dependencies; otherwise, restrict to target dependencies."
+ (define packages
+ (match (if native?
+ (append (bag-build-inputs bag)
+ (bag-target-inputs bag)
+ (if (bag-target bag)
+ '()
+ (bag-host-inputs bag)))
+ (bag-host-inputs bag))
+ (((labels things _ ...) ...)
+ things)))
+
+ (let loop ((packages packages)
+ (result seed)
+ (visited (setq)))
+ (match packages
+ (()
+ (values result visited))
+ (x
+ (let* ((packages (filter package? packages))
+ (visited (fold set-insert visited packages))
+ (inputs (append-map (compose bag-direct-inputs package->bag)
+ packages)))
+ (loop (remove (cut set-contains? visited <>)
+ (match inputs
+ (((labels things _ ...) ...)
+ things)))
+ (fold proc result packages)
+ visited))))))
- (append native-grafts target-grafts)))
+(define* (bag-grafts store bag)
+ "Return the list of grafts potentially applicable to BAG. Potentially
+applicable grafts are collected by looking at direct or indirect dependencies
+of BAG that have a 'replacement'. Whether a graft is actually applicable
+depends on whether the outputs of BAG depend on the items the grafts refer
+to (see 'graft-derivation'.)"
+ (define system (bag-system bag))
+ (define target (bag-target bag))
+
+ (define native-grafts
+ (let ((->graft (input-graft store system)))
+ (fold-bag-dependencies (lambda (package grafts)
+ (match (->graft package)
+ (#f grafts)
+ (graft (cons graft grafts))))
+ '()
+ bag)))
+
+ (define target-grafts
+ (if target
+ (let ((->graft (input-cross-graft store target system)))
+ (fold-bag-dependencies (lambda (package grafts)
+ (match (->graft package)
+ (#f grafts)
+ (graft (cons graft grafts))))
+ '()
+ bag
+ #:native? #f))
+ '()))
+
+ (append native-grafts target-grafts))
(define* (package-grafts store package
#:optional (system (%current-system))
@@ -985,6 +1021,9 @@ This is an internal procedure."
(grafts
(let ((guile (package-derivation store (default-guile)
system #:graft? #f)))
+ ;; TODO: As an optimization, we can simply graft the tip
+ ;; of the derivation graph since 'graft-derivation'
+ ;; recurses anyway.
(graft-derivation store drv grafts
#:system system
#:guile guile))))
diff --git a/tests/grafts.scm b/tests/grafts.scm
index 9fe314d..2cdcc14 100644
--- a/tests/grafts.scm
+++ b/tests/grafts.scm
@@ -17,12 +17,16 @@
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (test-grafts)
+ #:use-module (guix gexp)
+ #:use-module (guix monads)
#:use-module (guix derivations)
#:use-module (guix store)
#:use-module (guix utils)
#:use-module (guix grafts)
#:use-module (guix tests)
#:use-module ((gnu packages) #:select (search-bootstrap-binary))
+ #:use-module (gnu packages bootstrap)
+ #:use-module (srfi srfi-1)
#:use-module (srfi srfi-64)
#:use-module (rnrs io ports))
@@ -42,7 +46,7 @@
(test-begin "grafts")
-(test-assert "graft-derivation"
+(test-assert "graft-derivation, grafted item is a direct dependency"
(let* ((build `(begin
(mkdir %output)
(chdir %output)
@@ -51,29 +55,84 @@
(lambda (output)
(format output "foo/~a/bar" ,%mkdir)))
(symlink ,%bash "sh")))
- (orig (build-expression->derivation %store "graft" build
+ (orig (build-expression->derivation %store "grafted" build
+ #:inputs `(("a" ,%bash)
+ ("b" ,%mkdir))))
+ (one (add-text-to-store %store "bash" "fake bash"))
+ (two (build-expression->derivation %store "mkdir"
+ '(call-with-output-file %output
+ (lambda (port)
+ (display "fake mkdir"
port)))))
+ (grafted (graft-derivation %store orig
+ (list (graft
+ (origin %bash)
+ (replacement one))
+ (graft
+ (origin %mkdir)
+ (replacement two))))))
+ (and (build-derivations %store (list grafted))
+ (let ((two (derivation->output-path two))
+ (grafted (derivation->output-path grafted)))
+ (and (string=? (format #f "foo/~a/bar" two)
+ (call-with-input-file (string-append grafted "/text")
+ get-string-all))
+ (string=? (readlink (string-append grafted "/sh")) one)
+ (string=? (readlink (string-append grafted "/self"))
+ grafted))))))
+
+(test-assert "graft-derivation, grafted item is an indirect dependency"
+ (let* ((build `(begin
+ (mkdir %output)
+ (chdir %output)
+ (symlink %output "self")
+ (call-with-output-file "text"
+ (lambda (output)
+ (format output "foo/~a/bar" ,%mkdir)))
+ (symlink ,%bash "sh")))
+ (dep (build-expression->derivation %store "dep" build
#:inputs `(("a" ,%bash)
("b" ,%mkdir))))
+ (orig (build-expression->derivation %store "thing"
+ '(symlink
+ (assoc-ref %build-inputs
+ "dep")
+ %output)
+ #:inputs `(("dep" ,dep))))
(one (add-text-to-store %store "bash" "fake bash"))
(two (build-expression->derivation %store "mkdir"
'(call-with-output-file %output
(lambda (port)
(display "fake mkdir"
port)))))
- (graft (graft-derivation %store orig
- (list (graft
- (origin %bash)
- (replacement one))
- (graft
- (origin %mkdir)
- (replacement two))))))
- (and (build-derivations %store (list graft))
- (let ((two (derivation->output-path two))
- (graft (derivation->output-path graft)))
+ (grafted (graft-derivation %store orig
+ (list (graft
+ (origin %bash)
+ (replacement one))
+ (graft
+ (origin %mkdir)
+ (replacement two))))))
+ (and (build-derivations %store (list grafted))
+ (let* ((two (derivation->output-path two))
+ (grafted (derivation->output-path grafted))
+ (dep (readlink grafted)))
(and (string=? (format #f "foo/~a/bar" two)
- (call-with-input-file (string-append graft "/text")
+ (call-with-input-file (string-append dep "/text")
get-string-all))
- (string=? (readlink (string-append graft "/sh")) one)
- (string=? (readlink (string-append graft "/self")) graft))))))
+ (string=? (readlink (string-append dep "/sh")) one)
+ (string=? (readlink (string-append dep "/self")) dep)
+ (equal? (references %store grafted) (list dep))
+ (lset= string=?
+ (list one two dep)
+ (references %store dep)))))))
+
+(test-equal "cumulative-grafts, no dependencies on grafted output"
+ '()
+ (run-with-store %store
+ (mlet* %store-monad ((fake (text-file "bash" "Fake bash."))
+ (graft -> (graft
+ (origin %bash)
+ (replacement fake)))
+ (drv (gexp->derivation "foo" #~(mkdir #$output))))
+ ((store-lift cumulative-grafts) drv (list graft)))))
(test-assert "graft-derivation, multiple outputs"
(let* ((build `(begin