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
| | ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016 Petter <petter@mykolab.ch>
;;;
;;; 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 build go-build-system)
#:use-module (guix build utils)
#:use-module (guix build gremlin)
#:use-module (guix elf)
#:use-module (ice-9 ftw)
#:use-module (ice-9 match)
#:use-module (ice-9 regex)
#:use-module (ice-9 format)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-19)
#:use-module (srfi srfi-26)
#:use-module (rnrs io ports)
#:export (%standard-phases
go-build))
;; Commentary:
;;
;; Standard build procedure for packages using the GNU Build System or
;; something compatible ("./configure && make && make install"). This is the
;; builder-side code.
;;
;; Code:
(define* (set-SOURCE-DATE-EPOCH #:rest _)
"Set the 'SOURCE_DATE_EPOCH' environment variable. This is used by tools
that incorporate timestamps as a way to tell them to use a fixed timestamp.
See https://reproducible-builds.org/specs/source-date-epoch/."
(setenv "SOURCE_DATE_EPOCH" "1")
#t)
(define* (set-paths #:key target inputs native-inputs
#:allow-other-keys)
(define input-directories
(match inputs
(((_ . dir) ...)
dir)))
(define native-input-directories
(match native-inputs
(((_ . dir) ...)
dir)
(#f
'())))
(set-path-environment-variable "PATH" '("bin" "sbin")
(append native-input-directories
(if target
'()
input-directories)))
#t)
(define* (install-locale #:key
(locale "en_US.utf8")
(locale-category LC_ALL)
#:allow-other-keys)
"Try to install LOCALE; emit a warning if that fails. The main goal is to
use a UTF-8 locale so that Guile correctly interprets UTF-8 file names.
This phase must typically happen after 'set-paths' so that $LOCPATH has a
chance to be set."
(catch 'system-error
(lambda ()
(setlocale locale-category locale)
;; While we're at it, pass it to sub-processes.
(setenv (locale-category->string locale-category) locale)
(format (current-error-port) "using '~a' locale for category ~s~%"
locale (locale-category->string locale-category))
#t)
(lambda args
;; This is known to fail for instance in early bootstrap where locales
;; are not available.
(format (current-error-port)
"warning: failed to install '~a' locale: ~a~%"
locale (strerror (system-error-errno args)))
#t)))
(define* (unpack #:key source import-path unpack-path #:allow-other-keys)
"Unpack SOURCE in the working directory, and change directory within the
source. When SOURCE is a directory, copy it in a sub-directory of the current
working directory."
(if (string-null? import-path)
((display "WARNING: import-path is unset\n")))
(if (string-null? unpack-path)
(set! unpack-path import-path))
(mkdir-p "bin")
(mkdir-p "pkg")
(let ((src (string-append "src/" unpack-path)))
(mkdir-p src)
(copy-recursively source src)))
(define* (delete-files #:key import-path #:allow-other-keys) #t)
(define* (set-gopath #:key import-path #:allow-other-keys)
(setenv "GOPATH" (getcwd)))
(define* (symlinking #:key inputs #:allow-other-keys)
(for-each (lambda (input)
(let ((imppath (car input))
(storepath (cdr input)))
(if (and (not (string=? imppath "go"))
(not (string=? imppath "source")))
(begin
(mkdir-p (string-append
"src/"
(string-take imppath
(string-rindex imppath #\/))))
(let ((from (string-append storepath "/src/" imppath))
(to (string-append "src/" imppath)))
(if (file-exists? to) (delete-file-recursively to))
(symlink (string-append
storepath "/src/" imppath)
(string-append
"src/" imppath)))))))
inputs))
(define* (build #:key import-path #:allow-other-keys)
(system* "go" "install" import-path))
(define* (install #:key inputs outputs #:allow-other-keys)
(copy-recursively "bin" (string-append (assoc-ref outputs "out") "/bin"))
(copy-recursively "pkg" (string-append (assoc-ref outputs "out") "/pkg"))
(copy-recursively "src" (string-append (assoc-ref outputs "out") "/src")))
(define %standard-phases
;; Standard build phases, as a list of symbol/procedure pairs.
(let-syntax ((phases (syntax-rules ()
((_ p ...) `((p . ,p) ...)))))
(phases set-SOURCE-DATE-EPOCH set-paths install-locale unpack
delete-files set-gopath symlinking build install
)))
(define* (go-build #:key (source #f) (outputs #f) (inputs #f)
(phases %standard-phases)
#:allow-other-keys
#:rest args)
"Build from SOURCE to OUTPUTS, using INPUTS, and by running all of PHASES
in order. Return #t if all the PHASES succeeded, #f otherwise."
(define (elapsed-time end start)
(let ((diff (time-difference end start)))
(+ (time-second diff)
(/ (time-nanosecond diff) 1e9))))
(setvbuf (current-output-port) _IOLBF)
(setvbuf (current-error-port) _IOLBF)
;; Encoding/decoding errors shouldn't be silent.
(fluid-set! %default-port-conversion-strategy 'error)
;; The trick is to #:allow-other-keys everywhere, so that each procedure in
;; PHASES can pick the keyword arguments it's interested in.
(every (match-lambda
((name . proc)
(let ((start (current-time time-monotonic)))
(format #t "starting phase `~a'~%" name)
(let ((result (apply proc args))
(end (current-time time-monotonic)))
(format #t "phase `~a' ~:[failed~;succeeded~] after ~,1f seconds~%"
name result
(elapsed-time end start))
;; Dump the environment variables as a shell script, for handy debugging.
(system "export > $NIX_BUILD_TOP/environment-variables")
result))))
phases))
|