1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013, 2014, 2015, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2014 Deck Pickard <deck.r.pickard@gmail.com>
;;; Copyright © 2015, 2016 Alex Kost <alezost@gmail.com>
;;;
;;; 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 (guix scripts)
#:use-module (guix grafts)
#:use-module (guix utils)
#:use-module (guix ui)
#:use-module (guix store)
#:use-module (guix monads)
#:use-module (guix packages)
#:use-module (guix derivations)
#:use-module ((guix profiles) #:select (%profile-directory))
#:use-module (guix build syscalls)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-19)
#:use-module (srfi srfi-37)
#:use-module (ice-9 match)
#:export (args-fold*
parse-command-line
maybe-build
build-package
build-package-source
%distro-age-warning
warn-about-old-distro
%disk-space-warning
warn-about-disk-space))
;;; Commentary:
;;;
;;; General code for Guix scripts.
;;;
;;; Code:
(define (args-fold* options unrecognized-option-proc operand-proc . seeds)
"A wrapper on top of `args-fold' that does proper user-facing error
reporting."
(catch 'misc-error
(lambda ()
(apply args-fold options unrecognized-option-proc
operand-proc seeds))
(lambda (key proc msg args . rest)
;; XXX: MSG is not i18n'd.
(leave (G_ "invalid argument: ~a~%")
(apply format #f msg args)))))
(define (environment-build-options)
"Return additional build options passed as environment variables."
(arguments-from-environment-variable "GUIX_BUILD_OPTIONS"))
(define %default-argument-handler
;; The default handler for non-option command-line arguments.
(lambda (arg result)
(alist-cons 'argument arg result)))
(define* (parse-command-line args options seeds
#:key
(build-options? #t)
(argument-handler %default-argument-handler))
"Parse the command-line arguments ARGS according to OPTIONS (a list of
SRFI-37 options) and return the result, seeded by SEEDS. When BUILD-OPTIONS?
is true, also pass arguments passed via the 'GUIX_BUILD_OPTIONS' environment
variable. Command-line options take precedence those passed via
'GUIX_BUILD_OPTIONS'.
ARGUMENT-HANDLER is called for non-option arguments, like the 'operand-proc'
parameter of 'args-fold'."
(define (parse-options-from args seeds)
;; Actual parsing takes place here.
(apply args-fold* args options
(lambda (opt name arg . rest)
(leave (G_ "~A: unrecognized option~%") name))
argument-handler
seeds))
(call-with-values
(lambda ()
(if build-options?
(parse-options-from (environment-build-options) seeds)
(apply values seeds)))
(lambda seeds
;; ARGS take precedence over what the environment variable specifies.
(parse-options-from args seeds))))
(define* (maybe-build drvs
#:key dry-run? use-substitutes?)
"Show what will/would be built, and actually build DRVS, unless DRY-RUN? is
true."
(with-monad %store-monad
(>>= (show-what-to-build* drvs
#:dry-run? dry-run?
#:use-substitutes? use-substitutes?)
(lambda (_)
(if dry-run?
(return #f)
(built-derivations drvs))))))
(define* (build-package package
#:key dry-run? (use-substitutes? #t)
#:allow-other-keys
#:rest build-options)
"Build PACKAGE using BUILD-OPTIONS acceptable by 'set-build-options'.
Show what and how will/would be built."
(mlet %store-monad ((grafting? ((lift0 %graft? %store-monad))))
(apply set-build-options*
#:use-substitutes? use-substitutes?
(strip-keyword-arguments '(#:dry-run?) build-options))
(mlet %store-monad ((derivation (package->derivation
package #:graft? (and (not dry-run?)
grafting?))))
(mbegin %store-monad
(maybe-build (list derivation)
#:use-substitutes? use-substitutes?
#:dry-run? dry-run?)
(return (show-derivation-outputs derivation))))))
(define* (build-package-source package
#:key dry-run? (use-substitutes? #t)
#:allow-other-keys
#:rest build-options)
"Build PACKAGE source using BUILD-OPTIONS."
(mbegin %store-monad
(apply set-build-options*
#:use-substitutes? use-substitutes?
(strip-keyword-arguments '(#:dry-run?) build-options))
(mlet %store-monad ((derivation (origin->derivation
(package-source package))))
(mbegin %store-monad
(maybe-build (list derivation)
#:use-substitutes? use-substitutes?
#:dry-run? dry-run?)
(return (show-derivation-outputs derivation))))))
(define %distro-age-warning
;; The age (in seconds) above which we warn that the distro is too old.
(make-parameter (match (and=> (getenv "GUIX_DISTRO_AGE_WARNING")
string->duration)
(#f (* 7 24 3600))
(age (time-second age)))))
(define* (warn-about-old-distro #:optional (old (%distro-age-warning))
#:key (suggested-command
"guix package -u"))
"Emit a warning if Guix is older than OLD seconds."
(let-syntax ((false-if-not-found
(syntax-rules ()
((_ exp)
(catch 'system-error
(lambda ()
exp)
(lambda args
(if (= ENOENT (system-error-errno args))
#f
(apply throw args))))))))
(define (seconds->days seconds)
(round (/ seconds (* 3600 24))))
(define age
(match (false-if-not-found
(lstat (string-append %profile-directory "/current-guix")))
(#f #f)
(stat (- (time-second (current-time time-utc))
(stat:mtime stat)))))
(when (and age (>= age old))
(warning (N_ "Your Guix installation is ~a day old.\n"
"Your Guix installation is ~a days old.\n"
(seconds->days age))
(seconds->days age)))
(when (or (not age) (>= age old))
(warning (G_ "Consider running 'guix pull' followed by
'~a' to get up-to-date packages and security updates.\n")
suggested-command)
(newline (guix-warning-port)))))
(define %disk-space-warning
;; The fraction (between 0 and 1) of free disk space below which a warning
;; is emitted.
(make-parameter (match (and=> (getenv "GUIX_DISK_SPACE_WARNING")
string->number)
(#f .05) ;5%
(threshold (/ threshold 100.)))))
(define* (warn-about-disk-space #:optional profile
#:key
(threshold (%disk-space-warning)))
"Display a hint about 'guix gc' if less than THRESHOLD of /gnu/store is
available."
(let* ((stats (statfs (%store-prefix)))
(block-size (file-system-block-size stats))
(available (* block-size (file-system-blocks-available stats)))
(total (* block-size (file-system-block-count stats)))
(ratio (/ available total 1.)))
(when (< ratio threshold)
(warning (G_ "only ~,1f% of free space available on ~a~%")
(* ratio 100) (%store-prefix))
(if profile
(display-hint (format #f (G_ "Consider deleting old profile
generations and collecting garbage, along these lines:
@example
guix package -p ~s --delete-generations=1m
guix gc
@end example\n")
profile))
(display-hint (G_ "Consider running @command{guix gc} to free
space."))))))
;;; scripts.scm ends here
|