me
/
guix
Archived
1
0
Fork 0
Code

guix package: Re-apply package transformation when upgrading. 

* guix/scripts/package.scm (transaction-upgrade-entry)[upgrade]: Add
'transform' parameter.  Pass PKG through it.  Use
'manifest-entry-with-transformations'.
Call 'options->transformation' to get the transformation procedure.
* tests/guix-package.sh: Add 'guix package -u' test.
* tests/packages.scm ("transaction-upgrade-entry, transformation options preserved"):
New test.
* doc/guix.texi (Invoking guix package): Mention that transformations
are preserved across upgrades.
(Package Transformation Options): Likewise.
master
Ludovic Courtès 2020-09-25 17:16:34 +02:00
parent ad54a73bb8
commit 8e1907a724
No known key found for this signature in database
GPG Key ID: 090B11993D9AEBB5
4 changed files with 80 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
doc/guix.texi
View File

@ -3101,6 +3101,29 @@ in the distribution currently installed. To update your distribution,
you should regularly run @command{guix pull} (@pxref{Invoking guix
pull}).
@cindex package transformations, upgrades
When upgrading, package transformations that were originally applied
when creating the profile are automatically re-applied (@pxref{Package
Transformation Options}). For example, assume you first installed Emacs
from the tip of its development branch with:
@example
guix install emacs-next --with-branch=emacs-next=master
@end example
Next time you run @command{guix upgrade}, Guix will again pull the tip
of the Emacs development branch and build @code{emacs-next} from that
checkout.
Note that transformation options such as @option{--with-branch} and
@option{--with-source} depend on external state; it is up to you to
ensure that they work as expected. You can also discard a
transformations that apply to a package by running:
@example
guix install @var{package}
@end example
@item --do-not-upgrade[=@var{regexp} @dots{}]
When used together with the @option{--upgrade} option, do @emph{not}
upgrade any packages whose name matches a @var{regexp}. For example, to
@ -9193,6 +9216,10 @@ This is a convenient way to create customized packages on the fly
without having to type in the definitions of package variants
(@pxref{Defining Packages}).
Package transformation options are preserved across upgrades:
@command{guix upgrade} attempts to apply transformation options
initially used when creating the profile to the upgraded packages.
@table @code
@item --with-source=@var{source}

20
guix/scripts/package.scm
View File

@ -218,12 +218,13 @@ non-zero relevance score."
(output (manifest-entry-output old)))
transaction)))
(define (upgrade entry)
(define (upgrade entry transform)
(match entry
(($ <manifest-entry> name version output (? string? path))
(match (find-best-packages-by-name name #f)
((pkg . rest)
(let ((candidate-version (package-version pkg)))
(let* ((pkg (transform store pkg))
(candidate-version (package-version pkg)))
(match (package-superseded pkg)
((? package? new)
(supersede entry new))
@ -231,12 +232,14 @@ non-zero relevance score."
(case (version-compare candidate-version version)
((>)
(manifest-transaction-install-entry
(package->manifest-entry* pkg output)
(manifest-entry-with-transformations
(package->manifest-entry* pkg output))
transaction))
((<)
transaction)
((=)
(let* ((new (package->manifest-entry* pkg output)))
(let* ((new (manifest-entry-with-transformations
(package->manifest-entry* pkg output))))
;; Here we want to determine whether the NEW actually
;; differs from ENTRY, but we need to intercept
;; 'build-things' calls because they would prevent us from
@ -255,7 +258,14 @@ non-zero relevance score."
(if (manifest-transaction-removal-candidate? entry transaction)
transaction
(upgrade entry)))
;; Upgrade ENTRY, preserving transformation options listed in its
;; properties.
(let ((transform (options->transformation
(or (assq-ref (manifest-entry-properties entry)
'transformations)
'()))))
(upgrade entry transform))))
;;;

15
tests/guix-package.sh
View File

@ -184,6 +184,21 @@ grep -E 'emacs[[:blank:]]+42\.5\.9rc7' "$tmpfile"
rm "$emacs_tarball" "$tmpfile"
rmdir "$module_dir"
# Install with package transformations.
guix install --bootstrap -p "$profile" sed --with-input=sed=guile-bootstrap
grep "sed=guile-bootstrap" "$profile/manifest"
test "$(readlink -f "$profile/bin/guile")" \
= "$(guix build guile-bootstrap)/bin/guile"
test ! -f "$profile/bin/sed"
# Make sure the package transformation is preserved.
guix package --bootstrap -p "$profile" -u
grep "sed=guile-bootstrap" "$profile/manifest"
test "$(readlink -f "$profile/bin/guile")" \
= "$(guix build guile-bootstrap)/bin/guile"
test ! -f "$profile/bin/sed"
rm "$profile" "$profile"-[0-9]-link
# Profiles with a relative file name. Make sure we don't create dangling
# symlinks--see bug report at
# <https://lists.gnu.org/archive/html/guix-devel/2018-07/msg00036.html>.

23
tests/packages.scm
View File

@ -187,6 +187,29 @@
(string=? (manifest-pattern-version pattern) "1")
(string=? (manifest-pattern-output pattern) "out")))))))
(test-equal "transaction-upgrade-entry, transformation options preserved"
(derivation-file-name (package-derivation %store grep))
(let* ((old (dummy-package "emacs" (version "1")))
(props '((transformations . ((with-input . "emacs=grep")))))
(tx (transaction-upgrade-entry
%store
(manifest-entry
(inherit (package->manifest-entry old))
(properties props)
(item (string-append (%store-prefix) "/"
(make-string 32 #\e) "-foo-1")))
(manifest-transaction))))
(match (manifest-transaction-install tx)
(((? manifest-entry? entry))
(and (string=? (manifest-entry-version entry)
(package-version grep))
(string=? (manifest-entry-name entry)
(package-name grep))
(equal? (manifest-entry-properties entry) props)
(derivation-file-name
(package-derivation %store (manifest-entry-item entry))))))))
(test-assert "transaction-upgrade-entry, grafts"
;; Ensure that, when grafts are enabled, 'transaction-upgrade-entry' doesn't
;; try to build stuff.