2018-11-16 20:43:55 +09:00
|
|
|
;;; GNU Guix --- Functional package management for GNU
|
2020-02-10 14:47:56 +01:00
|
|
|
;;; Copyright © 2018, 2020 Mathieu Othacehe <m.othacehe@gmail.com>
|
2022-08-02 22:00:36 +02:00
|
|
|
;;; Copyright © 2019, 2020, 2022 Ludovic Courtès <ludo@gnu.org>
|
2020-01-03 19:26:54 +01:00
|
|
|
;;; Copyright © 2019, 2020 Tobias Geerinckx-Rice <me@tobias.gr>
|
2020-04-09 02:17:22 +02:00
|
|
|
;;; Copyright © 2020 Florian Pelz <pelzflorian@pelzflorian.de>
|
2024-10-21 08:00:56 +02:00
|
|
|
;;; Copyright © 2024 Janneke Nieuwenhuizen <janneke@gnu.org>
|
2018-11-16 20:43:55 +09:00
|
|
|
;;;
|
|
|
|
|
;;; This file is part of GNU Guix.
|
|
|
|
|
;;;
|
|
|
|
|
;;; GNU Guix is free software; you can redistribute it and/or modify it
|
|
|
|
|
;;; 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.
|
|
|
|
|
;;;
|
|
|
|
|
;;; GNU Guix is distributed in the hope that it will be useful, but
|
|
|
|
|
;;; 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
|
|
|
|
|
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
|
|
(define-module (gnu installer)
|
2018-12-05 14:57:28 +09:00
|
|
|
#:use-module (guix discovery)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:use-module (guix packages)
|
|
|
|
|
#:use-module (guix gexp)
|
|
|
|
|
#:use-module (guix modules)
|
|
|
|
|
#:use-module (guix utils)
|
2018-11-16 20:43:55 +09:00
|
|
|
#:use-module (guix ui)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:use-module ((guix self) #:select (make-config.scm))
|
2022-12-05 14:57:15 +01:00
|
|
|
#:use-module (guix describe)
|
|
|
|
|
#:use-module (guix channels)
|
2020-01-22 22:51:20 +01:00
|
|
|
#:use-module (guix packages)
|
|
|
|
|
#:use-module (guix git-download)
|
2020-02-19 12:08:40 +01:00
|
|
|
#:use-module (gnu installer utils)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:use-module (gnu packages admin)
|
|
|
|
|
#:use-module (gnu packages base)
|
|
|
|
|
#:use-module (gnu packages bash)
|
2021-12-29 13:45:26 +01:00
|
|
|
#:use-module (gnu packages compression)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:use-module (gnu packages connman)
|
installer: partionment: Add encryption support.
* gnu/installer.scm (set-installer-path): Add cryptsetup.
* gnu/installer/newt/partition.scm (prompt-luks-passwords): New procedure,
(run-partioning-page): Add the possibility to set encryption to "On" on a
partition and choose a label, add a new partition scheme: "Guided - using the
entire disk with encryption", prompt for encryption passwords before
proceeding to formating.
* gnu/installer/parted.scm (<user-partition>)[crypt-label],
[crypt-password]: New fields,
(partition-description): add the encryption label,
(user-partition-description): add an encryption field,
(auto-partition): add two partitioning schemes: entire-crypted-root and
entire-crypted-root-home,
(call-with-luks-key-file): new procedure,
(user-partition-upper-path): new procedure,
(luks-format-and-open): new procedure,
(luks-close): new procedure,
(format-user-partitions): format and open luks partitions before creating
file-system.
(mount-user-partitions): use the path returned by user-partition-upper-path,
(umount-user-partitions): close the luks partitions,
(user-partition->file-system): set device field to label for luks partitions
and to uuid for the rest,
(user-partition->mapped-device): new procedure,
(user-partitions->configuration): add mapped-devices field.
2018-12-07 14:04:25 +09:00
|
|
|
#:use-module (gnu packages cryptsetup)
|
2018-12-05 14:57:28 +09:00
|
|
|
#:use-module (gnu packages disk)
|
2020-01-03 19:26:54 +01:00
|
|
|
#:use-module (gnu packages file-systems)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:use-module (gnu packages guile)
|
gnu: Move most packages from guile.scm to new module.
* gnu/packages/guile.scm (artanis, guildhall, guile-aspell, guile-bash,
guile-8sync, guile-daemon, guile-dsv, guile-fibers, guile-syntax-highlight,
guile-sjson, guile-colorized, guile-pfds, guile-aa-tree, guile-simple-zmq,
jupyter-guile-kernel, guile-sparql, guile-debbugs, guile-email,
guile-debbugs-next, guile-newt, guile-mastodon, guile-parted, guile-xosd,
guile-dbi, guile-dbd-sqlite3, guile-config, guile-hall, guile-ics, guile-wisp,
guile-sly, g-wrap, guile-miniadapton, guile-reader, guile2.2-reader,
guile-ncurses, guile-ncurses/gpm, guile-lib, guile2.0-lib, guile2.2-lib,
guile-minikanren, guile2.0-minikanren, guile2.2-minikanren, guile-irregex,
guile2.0-irregex, guile2.2-irregex, haunt, guile2.0-haunt, guile2.2-haunt,
guile-redis, guile2.0-redis, guile2.2-redis, guile-commonmark,
guile2.0-commonmark, guile2.2-commonmark, mcron, mcron2): Move these variables
from here...
* gnu/packages/guile-xyz.scm: ...to this new file.
* gnu/local.mk (GNU_SYSTEM_MODULES): Add it.
* gnu/installer.scm,
gnu/packages/bioinformatics.scm,
gnu/packages/ci.scm,
gnu/packages/gtk.scm,
gnu/packages/guile.scm,
gnu/packages/mail.scm,
gnu/packages/package-management.scm,
gnu/packages/skribilo.scm,
gnu/packages/web.scm,
gnu/services/mcron.scm: Update module references.
2019-01-28 14:57:10 +01:00
|
|
|
#:use-module (gnu packages guile-xyz)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:autoload (gnu packages gnupg) (guile-gcrypt)
|
|
|
|
|
#:use-module (gnu packages iso-codes)
|
|
|
|
|
#:use-module (gnu packages linux)
|
|
|
|
|
#:use-module (gnu packages ncurses)
|
|
|
|
|
#:use-module (gnu packages package-management)
|
2022-11-03 17:57:51 +01:00
|
|
|
#:use-module (gnu packages pciutils)
|
2023-12-25 19:58:21 +02:00
|
|
|
#:use-module (gnu packages text-editors)
|
2021-12-28 11:19:55 +01:00
|
|
|
#:use-module (gnu packages tls)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:use-module (gnu packages xorg)
|
2019-05-13 23:30:51 +02:00
|
|
|
#:use-module (gnu system locale)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:use-module (ice-9 match)
|
2018-11-16 20:43:55 +09:00
|
|
|
#:use-module (srfi srfi-1)
|
2022-12-05 14:57:15 +01:00
|
|
|
#:use-module (web uri)
|
2018-11-24 12:25:03 +09:00
|
|
|
#:export (installer-program))
|
2018-11-16 20:43:55 +09:00
|
|
|
|
2019-03-26 23:06:51 +01:00
|
|
|
(define module-to-import?
|
|
|
|
|
;; Return true for modules that should be imported. For (gnu system …) and
|
|
|
|
|
;; (gnu packages …) modules, we simply add the whole 'guix' package via
|
|
|
|
|
;; 'with-extensions' (to avoid having to rebuild it all), which is why these
|
|
|
|
|
;; modules are excluded here.
|
2018-11-24 12:25:03 +09:00
|
|
|
(match-lambda
|
|
|
|
|
(('guix 'config) #f)
|
2019-03-26 23:06:51 +01:00
|
|
|
(('gnu 'installer _ ...) #t)
|
|
|
|
|
(('gnu 'build _ ...) #t)
|
|
|
|
|
(('guix 'build _ ...) #t)
|
2022-08-02 22:00:36 +02:00
|
|
|
(('guix 'read-print) #t)
|
2019-03-26 23:06:51 +01:00
|
|
|
(_ #f)))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
2020-03-22 15:51:40 +01:00
|
|
|
(define not-config?
|
|
|
|
|
;; Select (guix …) and (gnu …) modules, except (guix config).
|
|
|
|
|
(match-lambda
|
|
|
|
|
(('guix 'config) #f)
|
|
|
|
|
(('guix _ ...) #t)
|
|
|
|
|
(('gnu _ ...) #t)
|
|
|
|
|
(_ #f)))
|
|
|
|
|
|
2018-11-24 12:25:03 +09:00
|
|
|
(define* (build-compiled-file name locale-builder)
|
2020-09-22 15:20:58 +02:00
|
|
|
"Return a file-like object that evaluates the gexp LOCALE-BUILDER and store
|
2018-11-24 12:25:03 +09:00
|
|
|
its result in the scheme file NAME. The derivation will also build a compiled
|
|
|
|
|
version of this file."
|
|
|
|
|
(define set-utf8-locale
|
|
|
|
|
#~(begin
|
|
|
|
|
(setenv "LOCPATH"
|
2023-10-22 10:23:19 +02:00
|
|
|
#$(file-append
|
|
|
|
|
(libc-utf8-locales-for-target) "/lib/locale/"
|
|
|
|
|
(version-major+minor
|
|
|
|
|
(package-version (libc-utf8-locales-for-target)))))
|
2018-11-24 12:25:03 +09:00
|
|
|
(setlocale LC_ALL "en_US.utf8")))
|
|
|
|
|
|
|
|
|
|
(define builder
|
2019-07-21 23:05:54 +02:00
|
|
|
(with-extensions (list guile-json-3)
|
2020-03-22 15:51:40 +01:00
|
|
|
(with-imported-modules `(,@(source-module-closure
|
|
|
|
|
'((gnu installer locale))
|
|
|
|
|
#:select? not-config?)
|
|
|
|
|
((guix config) => ,(make-config.scm)))
|
2018-11-24 12:25:03 +09:00
|
|
|
#~(begin
|
|
|
|
|
(use-modules (gnu installer locale))
|
|
|
|
|
|
|
|
|
|
;; The locale files contain non-ASCII characters.
|
|
|
|
|
#$set-utf8-locale
|
|
|
|
|
|
|
|
|
|
(mkdir #$output)
|
|
|
|
|
(let ((locale-file
|
|
|
|
|
(string-append #$output "/" #$name ".scm"))
|
|
|
|
|
(locale-compiled-file
|
|
|
|
|
(string-append #$output "/" #$name ".go")))
|
|
|
|
|
(call-with-output-file locale-file
|
|
|
|
|
(lambda (port)
|
|
|
|
|
(write #$locale-builder port)))
|
|
|
|
|
(compile-file locale-file
|
|
|
|
|
#:output-file locale-compiled-file))))))
|
|
|
|
|
(computed-file name builder))
|
|
|
|
|
|
|
|
|
|
(define apply-locale
|
|
|
|
|
;; Install the specified locale.
|
2019-04-12 17:13:26 +02:00
|
|
|
(with-imported-modules (source-module-closure '((gnu services herd)))
|
|
|
|
|
#~(lambda (locale)
|
|
|
|
|
(false-if-exception
|
|
|
|
|
(setlocale LC_ALL locale))
|
|
|
|
|
|
|
|
|
|
;; Restart the documentation viewer so it displays the manual in
|
2020-04-01 14:43:35 +02:00
|
|
|
;; language that corresponds to LOCALE. Make sure that nothing is
|
|
|
|
|
;; printed on the console.
|
|
|
|
|
(parameterize ((shepherd-message-port
|
|
|
|
|
(%make-void-port "w")))
|
2020-04-14 12:56:44 +02:00
|
|
|
(stop-service 'term-tty2)
|
|
|
|
|
(start-service 'term-tty2 (list locale))))))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
|
|
|
|
(define* (compute-locale-step #:key
|
|
|
|
|
locales-name
|
|
|
|
|
iso639-languages-name
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
iso3166-territories-name
|
|
|
|
|
dry-run?)
|
2018-11-24 12:25:03 +09:00
|
|
|
"Return a gexp that run the locale-page of INSTALLER, and install the
|
|
|
|
|
selected locale. The list of locales, languages and territories passed to
|
|
|
|
|
locale-page are computed in derivations named respectively LOCALES-NAME,
|
|
|
|
|
ISO639-LANGUAGES-NAME and ISO3166-TERRITORIES-NAME. Those lists are compiled,
|
|
|
|
|
so that when the installer is run, all the lengthy operations have already
|
|
|
|
|
been performed at build time."
|
|
|
|
|
(define (compiled-file-loader file name)
|
|
|
|
|
#~(load-compiled
|
|
|
|
|
(string-append #$file "/" #$name ".go")))
|
|
|
|
|
|
|
|
|
|
(let* ((supported-locales #~(supported-locales->locales
|
2019-05-13 23:30:51 +02:00
|
|
|
#+(glibc-supported-locales)))
|
2024-09-27 11:14:44 +02:00
|
|
|
|
|
|
|
|
;; Note: Use the latest version of 'iso-codes', including
|
|
|
|
|
;; Guix-specific changes, so that all languages known to glibc and
|
|
|
|
|
;; returned by 'glibc-supported-locales'.
|
|
|
|
|
(iso-codes #~(string-append #$iso-codes "/share/iso-codes/json/"))
|
|
|
|
|
(iso639-3 #~(string-append #$iso-codes "iso_639-3.json"))
|
|
|
|
|
(iso639-5 #~(string-append #$iso-codes "iso_639-5.json"))
|
|
|
|
|
(iso3166 #~(string-append #$iso-codes "iso_3166-1.json"))
|
2018-11-24 12:25:03 +09:00
|
|
|
(locales-file (build-compiled-file
|
|
|
|
|
locales-name
|
|
|
|
|
#~`(quote ,#$supported-locales)))
|
|
|
|
|
(iso639-file (build-compiled-file
|
|
|
|
|
iso639-languages-name
|
|
|
|
|
#~`(quote ,(iso639->iso639-languages
|
|
|
|
|
#$supported-locales
|
|
|
|
|
#$iso639-3 #$iso639-5))))
|
|
|
|
|
(iso3166-file (build-compiled-file
|
|
|
|
|
iso3166-territories-name
|
|
|
|
|
#~`(quote ,(iso3166->iso3166-territories #$iso3166))))
|
|
|
|
|
(locales-loader (compiled-file-loader locales-file
|
|
|
|
|
locales-name))
|
|
|
|
|
(iso639-loader (compiled-file-loader iso639-file
|
|
|
|
|
iso639-languages-name))
|
|
|
|
|
(iso3166-loader (compiled-file-loader iso3166-file
|
|
|
|
|
iso3166-territories-name)))
|
|
|
|
|
#~(lambda (current-installer)
|
|
|
|
|
(let ((result
|
|
|
|
|
((installer-locale-page current-installer)
|
|
|
|
|
#:supported-locales #$locales-loader
|
|
|
|
|
#:iso639-languages #$iso639-loader
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
#:iso3166-territories #$iso3166-loader
|
|
|
|
|
#:dry-run? #$dry-run?)))
|
|
|
|
|
(if #$dry-run?
|
|
|
|
|
'()
|
|
|
|
|
(#$apply-locale result))
|
2018-12-05 14:30:16 +09:00
|
|
|
result))))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
|
|
|
|
(define apply-keymap
|
2018-12-05 14:36:22 +09:00
|
|
|
;; Apply the specified keymap. Use the default keyboard model.
|
2018-11-24 12:25:03 +09:00
|
|
|
#~(match-lambda
|
2020-04-09 02:17:22 +02:00
|
|
|
((layout variant options)
|
2018-12-05 14:36:22 +09:00
|
|
|
(kmscon-update-keymap (default-keyboard-model)
|
2020-04-09 02:17:22 +02:00
|
|
|
layout variant options))))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(define (compute-keymap-step context dry-run?)
|
2018-11-24 12:25:03 +09:00
|
|
|
"Return a gexp that runs the keymap-page of INSTALLER and install the
|
|
|
|
|
selected keymap."
|
|
|
|
|
#~(lambda (current-installer)
|
|
|
|
|
(let ((result
|
|
|
|
|
(call-with-values
|
|
|
|
|
(lambda ()
|
|
|
|
|
(xkb-rules->models+layouts
|
|
|
|
|
(string-append #$xkeyboard-config
|
|
|
|
|
"/share/X11/xkb/rules/base.xml")))
|
|
|
|
|
(lambda (models layouts)
|
|
|
|
|
((installer-keymap-page current-installer)
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
layouts '#$context #$dry-run?)))))
|
2021-01-12 16:26:07 +01:00
|
|
|
(and result (#$apply-keymap result))
|
2019-03-25 23:21:08 +01:00
|
|
|
result)))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(define* (installer-steps #:key dry-run?)
|
2018-11-24 12:25:03 +09:00
|
|
|
(let ((locale-step (compute-locale-step
|
|
|
|
|
#:locales-name "locales"
|
|
|
|
|
#:iso639-languages-name "iso639-languages"
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
#:iso3166-territories-name "iso3166-territories"
|
|
|
|
|
#:dry-run? dry-run?))
|
2018-11-24 12:25:03 +09:00
|
|
|
(timezone-data #~(string-append #$tzdata
|
|
|
|
|
"/share/zoneinfo/zone.tab")))
|
|
|
|
|
#~(lambda (current-installer)
|
2020-04-08 10:16:25 +02:00
|
|
|
((installer-parameters-menu current-installer)
|
2020-03-30 12:24:56 +02:00
|
|
|
(lambda ()
|
2020-04-08 10:16:25 +02:00
|
|
|
((installer-parameters-page current-installer)
|
2020-03-30 12:24:56 +02:00
|
|
|
(lambda _
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(#$(compute-keymap-step 'param dry-run?)
|
2020-03-30 12:24:56 +02:00
|
|
|
current-installer)))))
|
2018-11-24 12:25:03 +09:00
|
|
|
(list
|
2018-12-05 14:55:03 +09:00
|
|
|
;; Ask the user to choose a locale among those supported by
|
|
|
|
|
;; the glibc. Install the selected locale right away, so that
|
|
|
|
|
;; the user may benefit from any available translation for the
|
|
|
|
|
;; installer messages.
|
2018-11-24 12:25:03 +09:00
|
|
|
(installer-step
|
|
|
|
|
(id 'locale)
|
2018-12-05 14:30:16 +09:00
|
|
|
(description (G_ "Locale"))
|
2018-11-24 12:25:03 +09:00
|
|
|
(compute (lambda _
|
2018-12-05 14:30:16 +09:00
|
|
|
(#$locale-step current-installer)))
|
|
|
|
|
(configuration-formatter locale->configuration))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
2019-04-07 16:16:14 +02:00
|
|
|
;; Welcome the user and ask them to choose between manual
|
|
|
|
|
;; installation and graphical install.
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'welcome)
|
|
|
|
|
(compute (lambda _
|
|
|
|
|
((installer-welcome-page current-installer)
|
2022-11-03 17:57:51 +01:00
|
|
|
#$(local-file "installer/aux-files/logo.txt")
|
|
|
|
|
#:pci-database
|
|
|
|
|
#$(file-append pciutils "/share/hwdata/pci.ids.gz")))))
|
2019-04-07 16:16:14 +02:00
|
|
|
|
2018-11-24 12:25:03 +09:00
|
|
|
;; Ask the user to select a timezone under glibc format.
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'timezone)
|
2018-12-05 14:30:16 +09:00
|
|
|
(description (G_ "Timezone"))
|
2018-11-24 12:25:03 +09:00
|
|
|
(compute (lambda _
|
|
|
|
|
((installer-timezone-page current-installer)
|
2018-12-05 14:30:16 +09:00
|
|
|
#$timezone-data)))
|
|
|
|
|
(configuration-formatter posix-tz->configuration))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
|
|
|
|
;; The installer runs in a kmscon virtual terminal where loadkeys
|
|
|
|
|
;; won't work. kmscon uses libxkbcommon as a backend for keyboard
|
2020-04-09 02:17:22 +02:00
|
|
|
;; input. It is possible to update kmscon current keymap by sending
|
|
|
|
|
;; it a keyboard model, layout, variant and options, in a somehow
|
|
|
|
|
;; similar way as what is done with setxkbmap utility.
|
2018-11-24 12:25:03 +09:00
|
|
|
;;
|
|
|
|
|
;; So ask for a keyboard model, layout and variant to update the
|
2020-04-09 02:17:22 +02:00
|
|
|
;; current kmscon keymap. For non-Latin layouts, we add an
|
|
|
|
|
;; appropriate second layout and toggle via Alt+Shift.
|
2018-11-24 12:25:03 +09:00
|
|
|
(installer-step
|
|
|
|
|
(id 'keymap)
|
|
|
|
|
(description (G_ "Keyboard mapping selection"))
|
|
|
|
|
(compute (lambda _
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(if #$dry-run?
|
|
|
|
|
'("en" "US" #f)
|
|
|
|
|
(#$(compute-keymap-step 'default dry-run?)
|
|
|
|
|
current-installer))))
|
2019-03-25 23:21:08 +01:00
|
|
|
(configuration-formatter keyboard-layout->configuration))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
|
|
|
|
;; Ask the user to input a hostname for the system.
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'hostname)
|
2018-12-05 14:30:16 +09:00
|
|
|
(description (G_ "Hostname"))
|
2018-11-24 12:25:03 +09:00
|
|
|
(compute (lambda _
|
2018-12-05 14:30:16 +09:00
|
|
|
((installer-hostname-page current-installer))))
|
|
|
|
|
(configuration-formatter hostname->configuration))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
|
|
|
|
;; Provide an interface above connmanctl, so that the user can select
|
|
|
|
|
;; a network susceptible to acces Internet.
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'network)
|
|
|
|
|
(description (G_ "Network selection"))
|
|
|
|
|
(compute (lambda _
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(if #$dry-run?
|
|
|
|
|
'()
|
|
|
|
|
((installer-network-page current-installer))))))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
2020-12-04 11:33:16 +01:00
|
|
|
;; Ask whether to enable substitute server discovery.
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'substitutes)
|
|
|
|
|
(description (G_ "Substitute server discovery"))
|
|
|
|
|
(compute (lambda _
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(if #$dry-run?
|
|
|
|
|
'()
|
|
|
|
|
((installer-substitutes-page current-installer))))))
|
2020-12-04 11:33:16 +01:00
|
|
|
|
2018-11-24 12:25:03 +09:00
|
|
|
;; Prompt for users (name, group and home directory).
|
|
|
|
|
(installer-step
|
2018-12-05 14:30:16 +09:00
|
|
|
(id 'user)
|
|
|
|
|
(description (G_ "User creation"))
|
|
|
|
|
(compute (lambda _
|
|
|
|
|
((installer-user-page current-installer))))
|
|
|
|
|
(configuration-formatter users->configuration))
|
|
|
|
|
|
installer: Add "Kernel" page to select the Hurd.
This adds a "Kernel" page to the installer with the option to (cross-) install
the Hurd, if applicable (only available on x86 machines for now).
* gnu/installer/newt.scm (kernel-page): New procedure.
(newt-installer)[kernel-page]: New field.
* gnu/installer/kernel.scm,
gnu/installer/newt/kernel.scm: New files.
* gnu/local.mk (INSTALLER_MODULES): Add them.
* gnu/installer.scm (installer-steps): Use them to select kernel if
applicable.
* gnu/installer/newt/partition.scm (run-label-page): Default to "msdos" when
instaling the Hurd.
(run-fs-type-page): Add ext2 for the hurd.
(run-partitioning-page-partition): Remove `entire-encrypted' option when
installing the Hurd.
* gnu/installer/services.scm (system-services->configuration): Cater for the
Hurd with %base-services/hurd, and with %base-packages/hurd that must always
be set.
(%system-services): Change to procedure. When installing the the Hurd, do not
recommend `ntp-service-type' and USE `openssh-sans-x' package for
`openssh-service-type'.
(system-service-none): New variable.
* gnu/installer/newt/services.scm (run-network-management-page): Include it
when installing the Hurd.
(run-desktop-environments-cbt-page): When installing the Hurd, recommend to
not select any desktop enviroment. Update users.
* gnu/installer/parted.scm (efi-installation?): Return #f when installing for
the Hurd.
(create-ext2-file-system): New procedure.
(user-fs-type-name, user-fs-type->mount-type, partition-filesystem-user-type,
format-user-partitions): Support `ext2'.
(<user-partition> partition->user-partition): Use `ext2' when installing the
Hurd.
(auto-partition!): Likewise. No swap partition when installing the Hurd.
* gnu/installer/final.scm (install-system): Cater for cross installation of
the Hurd.
(bootloader-configuration): Use `grub-minimal-bootloader' when installing the
Hurd.
(user-partition-missing-modules): Cater for empty user-partitions.
(initrd-configuration, user-partitions->configuration): Cater for the Hurd.
* gnu/installer/steps.scm (format-configuration,
configuration->file): Cater for the Hurd.
* gnu/system/hurd.scm (%desktop-services/hurd): New variable.
* gnu/installer/tests.scm (choose-kernel): New procedure.
* gnu/tests/install.scm (gui-test-program): Use it.
Change-Id: Ifafb27b8a2f933944c77223a27ec151757237e36
2024-10-20 15:13:16 +02:00
|
|
|
;; Ask the user to select the kernel for the system,
|
|
|
|
|
;; for x86 systems only.
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'kernel)
|
|
|
|
|
(description (G_ "Kernel"))
|
|
|
|
|
(compute (lambda _
|
|
|
|
|
(if (target-x86?)
|
|
|
|
|
((installer-kernel-page current-installer))
|
|
|
|
|
'())))
|
|
|
|
|
(configuration-formatter (lambda (result)
|
|
|
|
|
(kernel->configuration result #$dry-run?))))
|
|
|
|
|
|
2018-12-05 14:41:48 +09:00
|
|
|
;; Ask the user to choose one or many desktop environment(s).
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'services)
|
|
|
|
|
(description (G_ "Services"))
|
2018-11-24 12:25:03 +09:00
|
|
|
(compute (lambda _
|
2018-12-05 14:41:48 +09:00
|
|
|
((installer-services-page current-installer))))
|
2020-03-28 18:40:41 +01:00
|
|
|
(configuration-formatter system-services->configuration))
|
2018-12-05 14:30:16 +09:00
|
|
|
|
2019-06-08 04:14:02 +02:00
|
|
|
;; Run a partitioning tool allowing the user to modify
|
|
|
|
|
;; partition tables, partitions and their mount points.
|
|
|
|
|
;; Do this last so the user has something to boot if any
|
|
|
|
|
;; of the previous steps didn't go as expected.
|
|
|
|
|
(installer-step
|
|
|
|
|
(id 'partition)
|
|
|
|
|
(description (G_ "Partitioning"))
|
|
|
|
|
(compute (lambda _
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(if #$dry-run?
|
|
|
|
|
'()
|
|
|
|
|
((installer-partitioning-page current-installer)))))
|
2019-06-08 04:14:02 +02:00
|
|
|
(configuration-formatter user-partitions->configuration))
|
|
|
|
|
|
2020-03-28 18:40:41 +01:00
|
|
|
(installer-step
|
2018-12-05 14:30:16 +09:00
|
|
|
(id 'final)
|
|
|
|
|
(description (G_ "Configuration file"))
|
|
|
|
|
(compute
|
|
|
|
|
(lambda (result prev-steps)
|
|
|
|
|
((installer-final-page current-installer)
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
result prev-steps #$dry-run?))))))))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
2022-12-05 14:57:15 +01:00
|
|
|
(define (provenance-sexp)
|
|
|
|
|
"Return an sexp representing the currently-used channels, for logging
|
|
|
|
|
purposes."
|
|
|
|
|
(match (match (current-channels)
|
|
|
|
|
(() (and=> (repository->guix-channel (dirname (current-filename)))
|
|
|
|
|
list))
|
|
|
|
|
(channels channels))
|
|
|
|
|
(#f
|
|
|
|
|
(warning (G_ "cannot determine installer provenance~%"))
|
|
|
|
|
'unknown)
|
|
|
|
|
((channels ...)
|
|
|
|
|
(map (lambda (channel)
|
|
|
|
|
(let* ((uri (string->uri (channel-url channel)))
|
|
|
|
|
(url (if (or (not uri) (eq? 'file (uri-scheme uri)))
|
|
|
|
|
"local checkout"
|
|
|
|
|
(channel-url channel))))
|
|
|
|
|
`(channel ,(channel-name channel) ,url ,(channel-commit channel))))
|
|
|
|
|
channels))))
|
|
|
|
|
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(define* (installer-program #:key dry-run?)
|
2018-11-24 12:25:03 +09:00
|
|
|
"Return a file-like object that runs the given INSTALLER."
|
|
|
|
|
(define init-gettext
|
|
|
|
|
;; Initialize gettext support, so that installer messages can be
|
|
|
|
|
;; translated.
|
|
|
|
|
#~(begin
|
|
|
|
|
(bindtextdomain "guix" (string-append #$guix "/share/locale"))
|
2020-10-16 15:02:00 +02:00
|
|
|
(textdomain "guix")
|
|
|
|
|
(setlocale LC_ALL "")))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
|
|
|
|
(define set-installer-path
|
|
|
|
|
;; Add the specified binary to PATH for later use by the installer.
|
|
|
|
|
#~(let* ((inputs
|
2024-10-20 13:51:44 +02:00
|
|
|
'#$(list bash ;start subshells
|
|
|
|
|
connman ;call connmanctl
|
2019-12-31 09:56:51 +01:00
|
|
|
cryptsetup
|
2024-10-20 13:51:44 +02:00
|
|
|
dosfstools ;mkfs.fat
|
|
|
|
|
e2fsprogs ;mkfs.ext4
|
|
|
|
|
lvm2-static ;dmsetup
|
2019-12-31 09:56:51 +01:00
|
|
|
btrfs-progs
|
2024-10-20 13:51:44 +02:00
|
|
|
jfsutils ;jfs_mkfs
|
|
|
|
|
ntfs-3g ;mkfs.ntfs
|
|
|
|
|
xfsprogs ;mkfs.xfs
|
|
|
|
|
kbd ;chvt
|
|
|
|
|
util-linux ;mkwap
|
2022-01-15 14:50:06 +01:00
|
|
|
nano
|
2019-12-31 09:56:51 +01:00
|
|
|
shadow
|
2024-10-20 13:51:44 +02:00
|
|
|
tar ;dump
|
|
|
|
|
gzip ;dump
|
2019-12-31 09:56:51 +01:00
|
|
|
coreutils)))
|
2018-11-24 12:25:03 +09:00
|
|
|
(with-output-to-port (%make-void-port "w")
|
|
|
|
|
(lambda ()
|
|
|
|
|
(set-path-environment-variable "PATH" '("bin" "sbin") inputs)))))
|
|
|
|
|
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(define steps (installer-steps #:dry-run? dry-run?))
|
2018-12-05 14:57:28 +09:00
|
|
|
(define modules
|
|
|
|
|
(scheme-modules*
|
|
|
|
|
(string-append (current-source-directory) "/..")
|
|
|
|
|
"gnu/installer"))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
|
|
|
|
(define installer-builder
|
2019-03-26 23:06:51 +01:00
|
|
|
;; Note: Include GUIX as an extension to get all the (gnu system …), (gnu
|
|
|
|
|
;; packages …), etc. modules.
|
2018-12-05 14:57:28 +09:00
|
|
|
(with-extensions (list guile-gcrypt guile-newt
|
|
|
|
|
guile-parted guile-bytestructures
|
2021-12-29 13:45:26 +01:00
|
|
|
guile-json-3 guile-git guile-webutils
|
2022-11-15 10:52:59 +01:00
|
|
|
guile-gnutls
|
2022-11-03 17:57:51 +01:00
|
|
|
guile-zlib ;for (gnu build linux-modules)
|
2024-05-12 20:51:50 -04:00
|
|
|
guile-zstd ;for (gnu build linux-modules)
|
2022-11-15 10:52:59 +01:00
|
|
|
(current-guix))
|
2018-11-24 12:25:03 +09:00
|
|
|
(with-imported-modules `(,@(source-module-closure
|
2018-12-05 14:57:28 +09:00
|
|
|
`(,@modules
|
2019-04-26 14:08:39 +02:00
|
|
|
(gnu services herd)
|
2018-11-24 12:25:03 +09:00
|
|
|
(guix build utils))
|
2019-03-26 23:06:51 +01:00
|
|
|
#:select? module-to-import?)
|
2018-11-24 12:25:03 +09:00
|
|
|
((guix config) => ,(make-config.scm)))
|
|
|
|
|
#~(begin
|
|
|
|
|
(use-modules (gnu installer record)
|
|
|
|
|
(gnu installer keymap)
|
|
|
|
|
(gnu installer steps)
|
2021-12-29 13:45:26 +01:00
|
|
|
(gnu installer dump)
|
2018-12-05 14:30:16 +09:00
|
|
|
(gnu installer final)
|
2018-12-05 14:45:53 +09:00
|
|
|
(gnu installer hostname)
|
installer: Add "Kernel" page to select the Hurd.
This adds a "Kernel" page to the installer with the option to (cross-) install
the Hurd, if applicable (only available on x86 machines for now).
* gnu/installer/newt.scm (kernel-page): New procedure.
(newt-installer)[kernel-page]: New field.
* gnu/installer/kernel.scm,
gnu/installer/newt/kernel.scm: New files.
* gnu/local.mk (INSTALLER_MODULES): Add them.
* gnu/installer.scm (installer-steps): Use them to select kernel if
applicable.
* gnu/installer/newt/partition.scm (run-label-page): Default to "msdos" when
instaling the Hurd.
(run-fs-type-page): Add ext2 for the hurd.
(run-partitioning-page-partition): Remove `entire-encrypted' option when
installing the Hurd.
* gnu/installer/services.scm (system-services->configuration): Cater for the
Hurd with %base-services/hurd, and with %base-packages/hurd that must always
be set.
(%system-services): Change to procedure. When installing the the Hurd, do not
recommend `ntp-service-type' and USE `openssh-sans-x' package for
`openssh-service-type'.
(system-service-none): New variable.
* gnu/installer/newt/services.scm (run-network-management-page): Include it
when installing the Hurd.
(run-desktop-environments-cbt-page): When installing the Hurd, recommend to
not select any desktop enviroment. Update users.
* gnu/installer/parted.scm (efi-installation?): Return #f when installing for
the Hurd.
(create-ext2-file-system): New procedure.
(user-fs-type-name, user-fs-type->mount-type, partition-filesystem-user-type,
format-user-partitions): Support `ext2'.
(<user-partition> partition->user-partition): Use `ext2' when installing the
Hurd.
(auto-partition!): Likewise. No swap partition when installing the Hurd.
* gnu/installer/final.scm (install-system): Cater for cross installation of
the Hurd.
(bootloader-configuration): Use `grub-minimal-bootloader' when installing the
Hurd.
(user-partition-missing-modules): Cater for empty user-partitions.
(initrd-configuration, user-partitions->configuration): Cater for the Hurd.
* gnu/installer/steps.scm (format-configuration,
configuration->file): Cater for the Hurd.
* gnu/system/hurd.scm (%desktop-services/hurd): New variable.
* gnu/installer/tests.scm (choose-kernel): New procedure.
* gnu/tests/install.scm (gui-test-program): Use it.
Change-Id: Ifafb27b8a2f933944c77223a27ec151757237e36
2024-10-20 15:13:16 +02:00
|
|
|
(gnu installer kernel)
|
2018-11-24 12:25:03 +09:00
|
|
|
(gnu installer locale)
|
2018-12-05 14:30:16 +09:00
|
|
|
(gnu installer parted)
|
|
|
|
|
(gnu installer services)
|
|
|
|
|
(gnu installer timezone)
|
|
|
|
|
(gnu installer user)
|
2020-04-18 17:41:11 +02:00
|
|
|
(gnu installer utils)
|
2018-11-24 12:25:03 +09:00
|
|
|
(gnu installer newt)
|
2019-03-25 23:21:08 +01:00
|
|
|
((gnu installer newt keymap)
|
|
|
|
|
#:select (keyboard-layout->configuration))
|
2019-04-12 17:13:26 +02:00
|
|
|
(gnu services herd)
|
2018-11-24 12:25:03 +09:00
|
|
|
(guix i18n)
|
|
|
|
|
(guix build utils)
|
installer: Add "Kernel" page to select the Hurd.
This adds a "Kernel" page to the installer with the option to (cross-) install
the Hurd, if applicable (only available on x86 machines for now).
* gnu/installer/newt.scm (kernel-page): New procedure.
(newt-installer)[kernel-page]: New field.
* gnu/installer/kernel.scm,
gnu/installer/newt/kernel.scm: New files.
* gnu/local.mk (INSTALLER_MODULES): Add them.
* gnu/installer.scm (installer-steps): Use them to select kernel if
applicable.
* gnu/installer/newt/partition.scm (run-label-page): Default to "msdos" when
instaling the Hurd.
(run-fs-type-page): Add ext2 for the hurd.
(run-partitioning-page-partition): Remove `entire-encrypted' option when
installing the Hurd.
* gnu/installer/services.scm (system-services->configuration): Cater for the
Hurd with %base-services/hurd, and with %base-packages/hurd that must always
be set.
(%system-services): Change to procedure. When installing the the Hurd, do not
recommend `ntp-service-type' and USE `openssh-sans-x' package for
`openssh-service-type'.
(system-service-none): New variable.
* gnu/installer/newt/services.scm (run-network-management-page): Include it
when installing the Hurd.
(run-desktop-environments-cbt-page): When installing the Hurd, recommend to
not select any desktop enviroment. Update users.
* gnu/installer/parted.scm (efi-installation?): Return #f when installing for
the Hurd.
(create-ext2-file-system): New procedure.
(user-fs-type-name, user-fs-type->mount-type, partition-filesystem-user-type,
format-user-partitions): Support `ext2'.
(<user-partition> partition->user-partition): Use `ext2' when installing the
Hurd.
(auto-partition!): Likewise. No swap partition when installing the Hurd.
* gnu/installer/final.scm (install-system): Cater for cross installation of
the Hurd.
(bootloader-configuration): Use `grub-minimal-bootloader' when installing the
Hurd.
(user-partition-missing-modules): Cater for empty user-partitions.
(initrd-configuration, user-partitions->configuration): Cater for the Hurd.
* gnu/installer/steps.scm (format-configuration,
configuration->file): Cater for the Hurd.
* gnu/system/hurd.scm (%desktop-services/hurd): New variable.
* gnu/installer/tests.scm (choose-kernel): New procedure.
* gnu/tests/install.scm (gui-test-program): Use it.
Change-Id: Ifafb27b8a2f933944c77223a27ec151757237e36
2024-10-20 15:13:16 +02:00
|
|
|
(guix utils)
|
2019-05-14 14:05:36 +02:00
|
|
|
((system repl debug)
|
|
|
|
|
#:select (terminal-width))
|
2022-01-15 14:50:11 +01:00
|
|
|
(ice-9 match)
|
|
|
|
|
(ice-9 textual-ports))
|
2018-11-24 12:25:03 +09:00
|
|
|
|
2022-10-31 13:03:46 +01:00
|
|
|
;; Enable core dump generation.
|
|
|
|
|
(setrlimit 'core #f #f)
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(unless #$dry-run?
|
|
|
|
|
(call-with-output-file "/proc/sys/kernel/core_pattern"
|
|
|
|
|
(lambda (port)
|
|
|
|
|
(format port %core-dump))))
|
2022-10-31 13:03:46 +01:00
|
|
|
|
2018-11-24 12:25:03 +09:00
|
|
|
;; Initialize gettext support so that installers can use
|
|
|
|
|
;; (guix i18n) module.
|
|
|
|
|
#$init-gettext
|
|
|
|
|
|
|
|
|
|
;; Add some binaries used by the installers to PATH.
|
|
|
|
|
#$set-installer-path
|
|
|
|
|
|
2019-04-17 11:07:21 +02:00
|
|
|
;; Arrange for language and territory name translations to be
|
|
|
|
|
;; available. We need them at run time, not just compile time,
|
|
|
|
|
;; because some territories have several corresponding languages
|
|
|
|
|
;; (e.g., "French" is always displayed as "français", but
|
|
|
|
|
;; "Belgium" could be translated to Dutch, French, or German.)
|
|
|
|
|
(bindtextdomain "iso_639-3" ;languages
|
2024-09-27 11:14:44 +02:00
|
|
|
#+(file-append iso-codes "/share/locale"))
|
2019-04-17 11:07:21 +02:00
|
|
|
(bindtextdomain "iso_3166-1" ;territories
|
2024-09-27 11:14:44 +02:00
|
|
|
#+(file-append iso-codes "/share/locale"))
|
2019-04-17 11:07:21 +02:00
|
|
|
|
2019-04-17 15:11:21 +02:00
|
|
|
;; Likewise for XKB keyboard layout names.
|
|
|
|
|
(bindtextdomain "xkeyboard-config"
|
|
|
|
|
#+(file-append xkeyboard-config "/share/locale"))
|
|
|
|
|
|
2019-05-14 14:05:36 +02:00
|
|
|
;; Initialize 'terminal-width' in (system repl debug)
|
|
|
|
|
;; to a large-enough value to make backtrace more
|
|
|
|
|
;; verbose.
|
|
|
|
|
(terminal-width 200)
|
|
|
|
|
|
2022-01-15 14:49:54 +01:00
|
|
|
(define current-installer newt-installer)
|
|
|
|
|
(define steps (#$steps current-installer))
|
2022-01-15 14:50:11 +01:00
|
|
|
|
2022-12-05 14:57:15 +01:00
|
|
|
(installer-log-line "installer provenance: ~s"
|
|
|
|
|
'#$(provenance-sexp))
|
|
|
|
|
|
2022-01-15 14:50:09 +01:00
|
|
|
(dynamic-wind
|
|
|
|
|
(installer-init current-installer)
|
|
|
|
|
(lambda ()
|
|
|
|
|
(parameterize
|
installer: Use `%' for parameter %run-command-in-installer.
* gnu/installer/utils.scm (run-command-in-installer): Rename to...
(%run-command-in-installer): ...this.
* gnu/installer.scm (installer-program): Update accordingly.
* gnu/installer/parted.scm (remove-logical-devices, create-btrfs-file-system,
create-ext4-file-system, create-fat16-file-system, create-fat32-file-system,
create-jfs-file-system, create-ntfs-file-system, create-xfs-file-system,
create-swap-partition, luks-format-and-open, luks-ensure-open, luks-close):
Update accordingly.
Change-Id: I96ebc59ebc85fd8ebccb0cc57130b4e7532d287f
2024-10-16 08:59:13 +02:00
|
|
|
((%run-command-in-installer
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
(if #$dry-run?
|
|
|
|
|
dry-run-command
|
|
|
|
|
(installer-run-command current-installer))))
|
2022-01-15 14:50:09 +01:00
|
|
|
(catch #t
|
|
|
|
|
(lambda ()
|
|
|
|
|
(define results
|
|
|
|
|
(run-installer-steps
|
|
|
|
|
#:rewind-strategy 'menu
|
|
|
|
|
#:menu-proc (installer-menu-page current-installer)
|
installer: Add dry-run?
This allows running the installer without root privileges. Do something like
./pre-inst-env guix repl
,use (guix)
,use (gnu installer)
(installer-program #:dry-run? #t)
,build $1
=>
"/gnu/store/...-installer-program"
and run
/gnu/store/...-installer-program
* gnu/installer/newt.scm (locale-page): Add #:dry-run? parameter.
(keymap-page): Likewise.
* gnu/installer/newt/keymap.scm (run-keymap-page): Likewise.
* gnu/installer/steps.scm (run-installer-steps): Likewise. Use it to skip
writing to socket.
* gnu/installer/newt/final.scm (run-final-page): Rename to...
(run-final-page-install): ...this.
(dry-run-final-page, run-final-page): New procedures.
* gnu/installer/parted.scm (bootloader-configuration): Cater for empty user
partitions.
* gnu/installer/utils.scm (dry-run-command): New procedure.
* gnu/installer.scm (compute-locale-step): Add #:dry-run? parameter. Use it
to avoid actually applying locale.
(compute-keymap-step): Add dry-run? parameter. Pass it to
keymap-page.
(installer-program): Add #:dry-run? parameter. If #:true
avoid writing to /proc, use dry-run-command, skip sync and reboot, and pass
dry-run? to...
(installer-steps): ...here. Add #:dry-run? parameter. Use it to disable
skip network, substitutes, partitioning pages, and pass it to...
compute-locale-step, compute-keymap-step, and final-page.
Change-Id: I0ff4c3b0a0c69539af617c27ba37654beed44619
2024-10-15 23:27:17 +02:00
|
|
|
#:steps steps
|
|
|
|
|
#:dry-run? #$dry-run?))
|
|
|
|
|
|
|
|
|
|
(let ((result (result-step results 'final)))
|
|
|
|
|
(unless #$dry-run?
|
|
|
|
|
(match (result-step results 'final)
|
|
|
|
|
('success
|
|
|
|
|
;; We did it! Let's reboot!
|
|
|
|
|
(sync)
|
|
|
|
|
(stop-service 'root))
|
|
|
|
|
(_
|
|
|
|
|
;; The installation failed, exit so that it is
|
|
|
|
|
;; restarted by login.
|
|
|
|
|
#f)))))
|
2022-01-15 14:50:09 +01:00
|
|
|
(const #f)
|
|
|
|
|
(lambda (key . args)
|
|
|
|
|
(installer-log-line "crashing due to uncaught exception: ~s ~s"
|
|
|
|
|
key args)
|
2022-01-15 14:50:11 +01:00
|
|
|
(define dump-dir
|
|
|
|
|
(prepare-dump key args #:result %current-result))
|
2022-10-31 16:43:09 +01:00
|
|
|
|
|
|
|
|
(define user-abort?
|
|
|
|
|
(match args
|
|
|
|
|
(((? user-abort-error? obj)) #t)
|
|
|
|
|
(_ #f)))
|
|
|
|
|
|
2022-01-15 14:50:11 +01:00
|
|
|
(define action
|
2022-10-31 16:43:09 +01:00
|
|
|
(if user-abort?
|
|
|
|
|
'dump
|
|
|
|
|
((installer-exit-error current-installer)
|
|
|
|
|
(get-string-all
|
|
|
|
|
(open-input-file
|
|
|
|
|
(string-append dump-dir
|
|
|
|
|
"/installer-backtrace"))))))
|
|
|
|
|
|
2022-01-15 14:50:11 +01:00
|
|
|
(match action
|
|
|
|
|
('dump
|
|
|
|
|
(let* ((dump-files
|
|
|
|
|
((installer-dump-page current-installer)
|
|
|
|
|
dump-dir))
|
|
|
|
|
(dump-archive
|
|
|
|
|
(make-dump dump-dir dump-files)))
|
|
|
|
|
((installer-report-page current-installer)
|
|
|
|
|
dump-archive)))
|
|
|
|
|
(_ #f))
|
|
|
|
|
(exit 1)))))
|
2022-01-15 14:50:09 +01:00
|
|
|
|
|
|
|
|
(installer-exit current-installer))))))
|
2018-11-16 20:43:55 +09:00
|
|
|
|
2018-11-24 14:06:40 +09:00
|
|
|
(program-file
|
|
|
|
|
"installer"
|
|
|
|
|
#~(begin
|
|
|
|
|
;; Set the default locale to install unicode support. For
|
|
|
|
|
;; some reason, unicode support is not correctly installed
|
|
|
|
|
;; when calling this in 'installer-builder'.
|
|
|
|
|
(setenv "LANG" "en_US.UTF-8")
|
2020-06-26 18:35:15 +02:00
|
|
|
(execl #$(program-file "installer-real" installer-builder
|
|
|
|
|
#:guile guile-3.0-latest)
|
2019-04-26 12:07:31 +02:00
|
|
|
"installer-real"))))
|