records: Add `recutils->alist' for public consumption.
[guix:guix.git] / guix / scripts / substitute-binary.scm
1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2013 Ludovic Courtès <ludo@gnu.org>
3 ;;;
4 ;;; This file is part of GNU Guix.
5 ;;;
6 ;;; GNU Guix is free software; you can redistribute it and/or modify it
7 ;;; under the terms of the GNU General Public License as published by
8 ;;; the Free Software Foundation; either version 3 of the License, or (at
9 ;;; your option) any later version.
10 ;;;
11 ;;; GNU Guix is distributed in the hope that it will be useful, but
12 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
13 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 ;;; GNU General Public License for more details.
15 ;;;
16 ;;; You should have received a copy of the GNU General Public License
17 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
18
19 (define-module (guix scripts substitute-binary)
20   #:use-module (guix ui)
21   #:use-module (guix store)
22   #:use-module (guix utils)
23   #:use-module (guix config)
24   #:use-module (guix records)
25   #:use-module (guix nar)
26   #:use-module ((guix build utils) #:select (mkdir-p))
27   #:use-module ((guix build download)
28                 #:select (progress-proc uri-abbreviation))
29   #:use-module (ice-9 rdelim)
30   #:use-module (ice-9 regex)
31   #:use-module (ice-9 match)
32   #:use-module (ice-9 threads)
33   #:use-module (ice-9 format)
34   #:use-module (ice-9 ftw)
35   #:use-module (ice-9 binary-ports)
36   #:use-module (srfi srfi-1)
37   #:use-module (srfi srfi-9)
38   #:use-module (srfi srfi-11)
39   #:use-module (srfi srfi-19)
40   #:use-module (srfi srfi-26)
41   #:use-module (web uri)
42   #:use-module (guix web)
43   #:export (guix-substitute-binary))
44
45 ;;; Comment:
46 ;;;
47 ;;; This is the "binary substituter".  It is invoked by the daemon do check
48 ;;; for the existence of available "substitutes" (pre-built binaries), and to
49 ;;; actually use them as a substitute to building things locally.
50 ;;;
51 ;;; If possible, substitute a binary for the requested store path, using a Nix
52 ;;; "binary cache".  This program implements the Nix "substituter" protocol.
53 ;;;
54 ;;; Code:
55
56 (define %narinfo-cache-directory
57   ;; A local cache of narinfos, to avoid going to the network.
58   (or (and=> (getenv "XDG_CACHE_HOME")
59              (cut string-append <> "/guix/substitute-binary"))
60       (string-append %state-directory "/substitute-binary/cache")))
61
62 (define %narinfo-ttl
63   ;; Number of seconds during which cached narinfo lookups are considered
64   ;; valid.
65   (* 24 3600))
66
67 (define %narinfo-negative-ttl
68   ;; Likewise, but for negative lookups---i.e., cached lookup failures.
69   (* 3 3600))
70
71 (define %narinfo-expired-cache-entry-removal-delay
72   ;; How often we want to remove files corresponding to expired cache entries.
73   (* 7 24 3600))
74
75 (define (with-atomic-file-output file proc)
76   "Call PROC with an output port for the file that is going to replace FILE.
77 Upon success, FILE is atomically replaced by what has been written to the
78 output port, and PROC's result is returned."
79   (let* ((template (string-append file ".XXXXXX"))
80          (out      (mkstemp! template)))
81     (with-throw-handler #t
82       (lambda ()
83         (let ((result (proc out)))
84           (close out)
85           (rename-file template file)
86           result))
87       (lambda (key . args)
88         (false-if-exception (delete-file template))))))
89
90 (define %regexp-exec-mutex
91   ;; In Guile 2.0.9, `regexp-exec' is thread-unsafe, so work around it.
92   ;; See <http://bugs.gnu.org/14404>.
93   (make-mutex))
94
95 (define string->uri
96   (let ((real (@ (web uri) string->uri)))
97     (lambda (uri)
98       "A thread-safe `string->uri'."
99       (with-mutex %regexp-exec-mutex
100         (real uri)))))
101
102 (define (fields->alist port)
103   "Read recutils-style record from PORT and return them as a list of key/value
104 pairs."
105   (with-mutex %regexp-exec-mutex
106     (recutils->alist port)))
107
108 (define %fetch-timeout
109   ;; Number of seconds after which networking is considered "slow".
110   3)
111
112 (define %random-state
113   (seed->random-state (+ (ash (cdr (gettimeofday)) 32) (getpid))))
114
115 (define-syntax-rule (with-timeout duration handler body ...)
116   "Run BODY; when DURATION seconds have expired, call HANDLER, and run BODY
117 again."
118   (begin
119     (sigaction SIGALRM
120       (lambda (signum)
121         (sigaction SIGALRM SIG_DFL)
122         handler))
123     (alarm duration)
124     (call-with-values
125         (lambda ()
126           (let try ()
127             (catch 'system-error
128               (lambda ()
129                 body ...)
130               (lambda args
131                 ;; The SIGALRM triggers EINTR, because of the bug at
132                 ;; <http://lists.gnu.org/archive/html/guile-devel/2013-06/msg00050.html>.
133                 ;; When that happens, try again.  Note: SA_RESTART cannot be
134                 ;; used because of <http://bugs.gnu.org/14640>.
135                 (if (= EINTR (system-error-errno args))
136                     (begin
137                       ;; Wait a little to avoid bursts.
138                       (usleep (random 3000000 %random-state))
139                       (try))
140                     (apply throw args))))))
141       (lambda result
142         (alarm 0)
143         (sigaction SIGALRM SIG_DFL)
144         (apply values result)))))
145
146 (define* (fetch uri #:key (buffered? #t) (timeout? #t))
147   "Return a binary input port to URI and the number of bytes it's expected to
148 provide."
149   (case (uri-scheme uri)
150     ((file)
151      (let ((port (open-input-file (uri-path uri))))
152        (unless buffered?
153          (setvbuf port _IONBF))
154        (values port (stat:size (stat port)))))
155     ((http)
156      ;; On Guile 2.0.5, `http-fetch' fetches the whole thing at once.  So
157      ;; honor TIMEOUT? to disable the timeout when fetching a nar.
158      ;;
159      ;; Test this with:
160      ;;   sudo tc qdisc add dev eth0 root netem delay 1500ms
161      ;; and then cancel with:
162      ;;   sudo tc qdisc del dev eth0 root
163      (let ((port #f))
164        (with-timeout (if (or timeout? (version>? (version) "2.0.5"))
165                          %fetch-timeout
166                          0)
167          (begin
168            (warning (_ "while fetching ~a: server is unresponsive~%")
169                     (uri->string uri))
170            (warning (_ "try `--no-substitutes' if the problem persists~%"))
171            (when port
172              (close-port port)))
173          (begin
174            (set! port (open-socket-for-uri uri #:buffered? buffered?))
175            (http-fetch uri #:text? #f #:port port)))))))
176
177 (define-record-type <cache>
178   (%make-cache url store-directory wants-mass-query?)
179   cache?
180   (url               cache-url)
181   (store-directory   cache-store-directory)
182   (wants-mass-query? cache-wants-mass-query?))
183
184 (define (open-cache url)
185   "Open the binary cache at URL.  Return a <cache> object on success, or #f on
186 failure."
187   (define (download-cache-info url)
188     ;; Download the `nix-cache-info' from URL, and return its contents as an
189     ;; list of key/value pairs.
190     (and=> (false-if-exception (fetch (string->uri url)))
191            fields->alist))
192
193   (and=> (download-cache-info (string-append url "/nix-cache-info"))
194          (lambda (properties)
195            (alist->record properties
196                           (cut %make-cache url <...>)
197                           '("StoreDir" "WantMassQuery")))))
198
199 (define-record-type <narinfo>
200   (%make-narinfo path uri compression file-hash file-size nar-hash nar-size
201                  references deriver system)
202   narinfo?
203   (path         narinfo-path)
204   (uri          narinfo-uri)
205   (compression  narinfo-compression)
206   (file-hash    narinfo-file-hash)
207   (file-size    narinfo-file-size)
208   (nar-hash     narinfo-hash)
209   (nar-size     narinfo-size)
210   (references   narinfo-references)
211   (deriver      narinfo-deriver)
212   (system       narinfo-system))
213
214 (define (narinfo-maker cache-url)
215   "Return a narinfo constructor for narinfos originating from CACHE-URL."
216   (lambda (path url compression file-hash file-size nar-hash nar-size
217                 references deriver system)
218     "Return a new <narinfo> object."
219     (%make-narinfo path
220
221                    ;; Handle the case where URL is a relative URL.
222                    (or (string->uri url)
223                        (string->uri (string-append cache-url "/" url)))
224
225                    compression file-hash
226                    (and=> file-size string->number)
227                    nar-hash
228                    (and=> nar-size string->number)
229                    (string-tokenize references)
230                    (match deriver
231                      ((or #f "") #f)
232                      (_ deriver))
233                    system)))
234
235 (define* (read-narinfo port #:optional url)
236   "Read a narinfo from PORT in its standard external form.  If URL is true, it
237 must be a string used to build full URIs from relative URIs found while
238 reading PORT."
239   (alist->record (fields->alist port)
240                  (narinfo-maker url)
241                  '("StorePath" "URL" "Compression"
242                    "FileHash" "FileSize" "NarHash" "NarSize"
243                    "References" "Deriver" "System")))
244
245 (define (write-narinfo narinfo port)
246   "Write NARINFO to PORT."
247   (define (empty-string-if-false x)
248     (or x ""))
249
250   (define (number-or-empty-string x)
251     (if (number? x)
252         (number->string x)
253         ""))
254
255   (object->fields narinfo
256                   `(("StorePath" . ,narinfo-path)
257                     ("URL" . ,(compose uri->string narinfo-uri))
258                     ("Compression" . ,narinfo-compression)
259                     ("FileHash" . ,(compose empty-string-if-false
260                                             narinfo-file-hash))
261                     ("FileSize" . ,(compose number-or-empty-string
262                                             narinfo-file-size))
263                     ("NarHash" . ,(compose empty-string-if-false
264                                            narinfo-hash))
265                     ("NarSize" . ,(compose number-or-empty-string
266                                            narinfo-size))
267                     ("References" . ,(compose string-join narinfo-references))
268                     ("Deriver" . ,(compose empty-string-if-false
269                                            narinfo-deriver))
270                     ("System" . ,narinfo-system))
271                   port))
272
273 (define (narinfo->string narinfo)
274   "Return the external representation of NARINFO."
275   (call-with-output-string (cut write-narinfo narinfo <>)))
276
277 (define (string->narinfo str)
278   "Return the narinfo represented by STR."
279   (call-with-input-string str (cut read-narinfo <>)))
280
281 (define (fetch-narinfo cache path)
282   "Return the <narinfo> record for PATH, or #f if CACHE does not hold PATH."
283   (define (download url)
284     ;; Download the .narinfo from URL, and return its contents as a list of
285     ;; key/value pairs.
286     (false-if-exception (fetch (string->uri url))))
287
288   (and (string=? (cache-store-directory cache) (%store-prefix))
289        (and=> (download (string-append (cache-url cache) "/"
290                                        (store-path-hash-part path)
291                                        ".narinfo"))
292               (cute read-narinfo <> (cache-url cache)))))
293
294 (define (obsolete? date now ttl)
295   "Return #t if DATE is obsolete compared to NOW + TTL seconds."
296   (time>? (subtract-duration now (make-time time-duration 0 ttl))
297           (make-time time-monotonic 0 date)))
298
299 (define (lookup-narinfo cache path)
300   "Check locally if we have valid info about PATH, otherwise go to CACHE and
301 check what it has."
302   (define now
303     (current-time time-monotonic))
304
305   (define cache-file
306     (string-append %narinfo-cache-directory "/"
307                    (store-path-hash-part path)))
308
309   (define (cache-entry narinfo)
310     `(narinfo (version 0)
311               (date ,(time-second now))
312               (value ,(and=> narinfo narinfo->string))))
313
314   (let*-values (((valid? cached)
315                  (catch 'system-error
316                    (lambda ()
317                      (call-with-input-file cache-file
318                        (lambda (p)
319                          (match (read p)
320                            (('narinfo ('version 0) ('date date)
321                                       ('value #f))
322                             ;; A cached negative lookup.
323                             (if (obsolete? date now %narinfo-negative-ttl)
324                                 (values #f #f)
325                                 (values #t #f)))
326                            (('narinfo ('version 0) ('date date)
327                                       ('value value))
328                             ;; A cached positive lookup
329                             (if (obsolete? date now %narinfo-ttl)
330                                 (values #f #f)
331                                 (values #t (string->narinfo value))))))))
332                    (lambda _
333                      (values #f #f)))))
334     (if valid?
335         cached                                    ; including negative caches
336         (let* ((cache   (force cache))
337                (narinfo (and cache (fetch-narinfo cache path))))
338           ;; Cache NARINFO only when CACHE was actually accessible.  This
339           ;; avoids caching negative hits when in fact we just lacked network
340           ;; access.
341           (when cache
342             (with-atomic-file-output cache-file
343               (lambda (out)
344                 (write (cache-entry narinfo) out))))
345           narinfo))))
346
347 (define (remove-expired-cached-narinfos)
348   "Remove expired narinfo entries from the cache.  The sole purpose of this
349 function is to make sure `%narinfo-cache-directory' doesn't grow
350 indefinitely."
351   (define now
352     (current-time time-monotonic))
353
354   (define (expired? file)
355     (catch 'system-error
356       (lambda ()
357         (call-with-input-file file
358           (lambda (port)
359             (match (read port)
360               (('narinfo ('version 0) ('date date)
361                          ('value #f))
362                (obsolete? date now %narinfo-negative-ttl))
363               (('narinfo ('version 0) ('date date)
364                          ('value _))
365                (obsolete? date now %narinfo-ttl))
366               (_ #t)))))
367       (lambda args
368         ;; FILE may have been deleted.
369         #t)))
370
371   (for-each (lambda (file)
372               (let ((file (string-append %narinfo-cache-directory
373                                          "/" file)))
374                 (when (expired? file)
375                   ;; Wrap in `false-if-exception' because FILE might have been
376                   ;; deleted in the meantime (TOCTTOU).
377                   (false-if-exception (delete-file file)))))
378             (scandir %narinfo-cache-directory
379                      (lambda (file)
380                        (= (string-length file) 32)))))
381
382 (define (maybe-remove-expired-cached-narinfo)
383   "Remove expired narinfo entries from the cache if deemed necessary."
384   (define now
385     (current-time time-monotonic))
386
387   (define expiry-file
388     (string-append %narinfo-cache-directory "/last-expiry-cleanup"))
389
390   (define last-expiry-date
391     (or (false-if-exception
392          (call-with-input-file expiry-file read))
393         0))
394
395   (when (obsolete? last-expiry-date now %narinfo-expired-cache-entry-removal-delay)
396     (remove-expired-cached-narinfos)
397     (call-with-output-file expiry-file
398       (cute write (time-second now) <>))))
399
400 (define (decompressed-port compression input)
401   "Return an input port where INPUT is decompressed according to COMPRESSION,
402 along with a list of PIDs to wait for."
403   (match compression
404     ("none"  (values input '()))
405     ("bzip2" (filtered-port `(,%bzip2 "-dc") input))
406     ("xz"    (filtered-port `(,%xz "-dc") input))
407     ("gzip"  (filtered-port `(,%gzip "-dc") input))
408     (else    (error "unsupported compression scheme" compression))))
409
410 (define (progress-report-port report-progress port)
411   "Return a port that calls REPORT-PROGRESS every time something is read from
412 PORT.  REPORT-PROGRESS is a two-argument procedure such as that returned by
413 `progress-proc'."
414   (define total 0)
415   (define (read! bv start count)
416     (let ((n (match (get-bytevector-n! port bv start count)
417                ((? eof-object?) 0)
418                (x x))))
419       (set! total (+ total n))
420       (report-progress total (const n))
421       ;; XXX: We're not in control, so we always return anyway.
422       n))
423
424   (make-custom-binary-input-port "progress-port-proc"
425                                  read! #f #f
426                                  (cut close-port port)))
427
428 (define %cache-url
429   (or (getenv "GUIX_BINARY_SUBSTITUTE_URL")
430       "http://hydra.gnu.org"))
431
432 (define-syntax with-networking
433   (syntax-rules ()
434     "Catch DNS lookup errors and gracefully exit."
435     ;; Note: no attempt is made to catch other networking errors, because DNS
436     ;; lookup errors are typically the first one, and because other errors are
437     ;; a subset of `system-error', which is harder to filter.
438     ((_ exp ...)
439      (catch 'getaddrinfo-error
440        (lambda () exp ...)
441        (lambda (key error)
442          (leave (_ "host name lookup error: ~a~%")
443                 (gai-strerror error)))))))
444
445 \f
446 ;;;
447 ;;; Entry point.
448 ;;;
449
450 (define (guix-substitute-binary . args)
451   "Implement the build daemon's substituter protocol."
452   (mkdir-p %narinfo-cache-directory)
453   (maybe-remove-expired-cached-narinfo)
454   (with-networking
455    (match args
456      (("--query")
457       (let ((cache (delay (open-cache %cache-url))))
458         (let loop ((command (read-line)))
459           (or (eof-object? command)
460               (begin
461                 (match (string-tokenize command)
462                   (("have" paths ..1)
463                    ;; Return the subset of PATHS available in CACHE.
464                    (let ((substitutable
465                           (if cache
466                               (par-map (cut lookup-narinfo cache <>)
467                                        paths)
468                               '())))
469                      (for-each (lambda (narinfo)
470                                  (when narinfo
471                                    (format #t "~a~%" (narinfo-path narinfo))))
472                                (filter narinfo? substitutable))
473                      (newline)))
474                   (("info" paths ..1)
475                    ;; Reply info about PATHS if it's in CACHE.
476                    (let ((substitutable
477                           (if cache
478                               (par-map (cut lookup-narinfo cache <>)
479                                        paths)
480                               '())))
481                      (for-each (lambda (narinfo)
482                                  (format #t "~a\n~a\n~a\n"
483                                          (narinfo-path narinfo)
484                                          (or (and=> (narinfo-deriver narinfo)
485                                                     (cute string-append
486                                                           (%store-prefix) "/"
487                                                           <>))
488                                              "")
489                                          (length (narinfo-references narinfo)))
490                                  (for-each (cute format #t "~a/~a~%"
491                                                  (%store-prefix) <>)
492                                            (narinfo-references narinfo))
493                                  (format #t "~a\n~a\n"
494                                          (or (narinfo-file-size narinfo) 0)
495                                          (or (narinfo-size narinfo) 0)))
496                                (filter narinfo? substitutable))
497                      (newline)))
498                   (wtf
499                    (error "unknown `--query' command" wtf)))
500                 (loop (read-line)))))))
501      (("--substitute" store-path destination)
502       ;; Download STORE-PATH and add store it as a Nar in file DESTINATION.
503       (let* ((cache   (delay (open-cache %cache-url)))
504              (narinfo (lookup-narinfo cache store-path))
505              (uri     (narinfo-uri narinfo)))
506         ;; Tell the daemon what the expected hash of the Nar itself is.
507         (format #t "~a~%" (narinfo-hash narinfo))
508
509         (format (current-error-port) "downloading `~a' from `~a'...~%"
510                 store-path (uri->string uri))
511         (let*-values (((raw download-size)
512                        ;; Note that Hydra currently generates Nars on the fly
513                        ;; and doesn't specify a Content-Length, so
514                        ;; DOWNLOAD-SIZE is #f in practice.
515                        (fetch uri #:buffered? #f #:timeout? #f))
516                       ((progress)
517                        (let* ((comp     (narinfo-compression narinfo))
518                               (dl-size  (or download-size
519                                             (and (equal? comp "none")
520                                                  (narinfo-size narinfo))))
521                               (progress (progress-proc (uri-abbreviation uri)
522                                                        dl-size
523                                                        (current-error-port))))
524                          (progress-report-port progress raw)))
525                       ((input pids)
526                        (decompressed-port (narinfo-compression narinfo)
527                                           progress)))
528           ;; Unpack the Nar at INPUT into DESTINATION.
529           (restore-file input destination)
530           (every (compose zero? cdr waitpid) pids))))
531      (("--version")
532       (show-version-and-exit "guix substitute-binary")))))
533
534
535 ;;; Local Variables:
536 ;;; eval: (put 'with-atomic-file-output 'scheme-indent-function 1)
537 ;;; eval: (put 'with-timeout 'scheme-indent-function 1)
538 ;;; End:
539
540 ;;; substitute-binary.scm ends here