aboutsummaryrefslogtreecommitdiffstats
path: root/build/update-license.go
blob: 5307f12ae33799e4e0196de3566a97963644684f (plain) (blame)
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
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
// +build none

/*
This command generates GPL license headers on top of all source files.
You can run it once per month, before cutting a release or just
whenever you feel like it.

    go run update-license.go

All authors (people who have contributed code) are listed in the
AUTHORS file. The author names are mapped and deduplicated using the
.mailmap file. You can use .mailmap to set the canonical name and
address for each author. See git-shortlog(1) for an explanation of the
.mailmap format.

Please review the resulting diff to check whether the correct
copyright assignments are performed.
*/
package main

import (
    "bufio"
    "bytes"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "os/exec"
    "path/filepath"
    "regexp"
    "runtime"
    "sort"
    "strconv"
    "strings"
    "sync"
    "text/template"
    "time"
)

var (
    // only files with these extensions will be considered
    extensions = []string{".go", ".js", ".qml"}

    // paths with any of these prefixes will be skipped
    skipPrefixes = []string{
        // boring stuff
        "Godeps/", "tests/files/", "build/",
        // don't relicense vendored packages
        "crypto/sha3/", "crypto/ecies/", "logger/glog/",
    }

    // paths with this prefix are licensed as GPL. all other files are LGPL.
    gplPrefixes = []string{"cmd/"}

    // this regexp must match the entire license comment at the
    // beginning of each file.
    licenseCommentRE = regexp.MustCompile(`(?s)^/\*\s*(Copyright|This file is part of) .*?\*/\n*`)

    // this text appears at the start of AUTHORS
    authorsFileHeader = "# This is the official list of go-ethereum authors for copyright purposes.\n\n"
)

// this template generates the license comment.
// its input is an info structure.
var licenseT = template.Must(template.New("").Parse(`
// Copyright {{.Year}} The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU {{.License}} as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// go-ethereum 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 {{.License}} for more details.
//
// You should have received a copy of the GNU {{.License}}
// along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.

`[1:]))

type info struct {
    file string
    Year int64
}

func (i info) License() string {
    if i.gpl() {
        return "General Public License"
    } else {
        return "Lesser General Public License"
    }
}

func (i info) ShortLicense() string {
    if i.gpl() {
        return "GPL"
    } else {
        return "LGPL"
    }
}

func (i info) gpl() bool {
    for _, p := range gplPrefixes {
        if strings.HasPrefix(i.file, p) {
            return true
        }
    }
    return false
}

func main() {
    var (
        files = getFiles()
        filec = make(chan string)
        infoc = make(chan *info, 20)
        wg    sync.WaitGroup
    )

    writeAuthors(files)

    go func() {
        for _, f := range files {
            filec <- f
        }
        close(filec)
    }()
    for i := runtime.NumCPU(); i >= 0; i-- {
        // getting file info is slow and needs to be parallel.
        // it traverses git history for each file.
        wg.Add(1)
        go getInfo(filec, infoc, &wg)
    }
    go func() {
        wg.Wait()
        close(infoc)
    }()
    writeLicenses(infoc)
}

func getFiles() []string {
    cmd := exec.Command("git", "ls-tree", "-r", "--name-only", "HEAD")
    var files []string
    err := doLines(cmd, func(line string) {
        for _, p := range skipPrefixes {
            if strings.HasPrefix(line, p) {
                return
            }
        }
        ext := filepath.Ext(line)
        for _, wantExt := range extensions {
            if ext == wantExt {
                goto keep
            }
        }
        return
    keep:
        files = append(files, line)
    })
    if err != nil {
        log.Fatalf("error getting files:", err)
    }
    return files
}

var authorRegexp = regexp.MustCompile(`\s*[0-9]+\s*(.*)`)

func gitAuthors(files []string) []string {
    cmds := []string{"shortlog", "-s", "-n", "-e", "HEAD", "--"}
    cmds = append(cmds, files...)
    cmd := exec.Command("git", cmds...)
    var authors []string
    err := doLines(cmd, func(line string) {
        m := authorRegexp.FindStringSubmatch(line)
        if len(m) > 1 {
            authors = append(authors, m[1])
        }
    })
    if err != nil {
        log.Fatalln("error getting authors:", err)
    }
    return authors
}

func readAuthors() []string {
    content, err := ioutil.ReadFile("AUTHORS")
    if err != nil && !os.IsNotExist(err) {
        log.Fatalln("error reading AUTHORS:", err)
    }
    var authors []string
    for _, a := range bytes.Split(content, []byte("\n")) {
        if len(a) > 0 && a[0] != '#' {
            authors = append(authors, string(a))
        }
    }
    // Retranslate existing authors through .mailmap.
    // This should catch email address changes.
    authors = mailmapLookup(authors)
    return authors
}

func mailmapLookup(authors []string) []string {
    if len(authors) == 0 {
        return nil
    }
    cmds := []string{"check-mailmap", "--"}
    cmds = append(cmds, authors...)
    cmd := exec.Command("git", cmds...)
    var translated []string
    err := doLines(cmd, func(line string) {
        translated = append(translated, line)
    })
    if err != nil {
        log.Fatalln("error translating authors:", err)
    }
    return translated
}

func writeAuthors(files []string) {
    merge := make(map[string]bool)
    // Add authors that Git reports as contributorxs.
    // This is the primary source of author information.
    for _, a := range gitAuthors(files) {
        merge[a] = true
    }
    // Add existing authors from the file. This should ensure that we
    // never lose authors, even if Git stops listing them. We can also
    // add authors manually this way.
    for _, a := range readAuthors() {
        merge[a] = true
    }
    // Write sorted list of authors back to the file.
    var result []string
    for a := range merge {
        result = append(result, a)
    }
    sort.Strings(result)
    content := new(bytes.Buffer)
    content.WriteString(authorsFileHeader)
    for _, a := range result {
        content.WriteString(a)
        content.WriteString("\n")
    }
    fmt.Println("writing AUTHORS")
    if err := ioutil.WriteFile("AUTHORS", content.Bytes(), 0644); err != nil {
        log.Fatalln(err)
    }
}

func getInfo(files <-chan string, out chan<- *info, wg *sync.WaitGroup) {
    for file := range files {
        stat, err := os.Lstat(file)
        if err != nil {
            fmt.Printf("ERROR %s: %v\n", file, err)
            continue
        }
        if !stat.Mode().IsRegular() {
            continue
        }
        info, err := fileInfo(file)
        if err != nil {
            fmt.Printf("ERROR %s: %v\n", file, err)
            continue
        }
        out <- info
    }
    wg.Done()
}

// fileInfo finds the lowest year in which the given file was commited.
func fileInfo(file string) (*info, error) {
    info := &info{file: file, Year: int64(time.Now().Year())}
    cmd := exec.Command("git", "log", "--follow", "--find-copies", "--pretty=format:%ai", "--", file)
    err := doLines(cmd, func(line string) {
        y, err := strconv.ParseInt(line[:4], 10, 64)
        if err != nil {
            fmt.Printf("cannot parse year: %q", line[:4])
        }
        if y < info.Year {
            info.Year = y
        }
    })
    return info, err
}

func writeLicenses(infos <-chan *info) {
    for i := range infos {
        writeLicense(i)
    }
}

func writeLicense(info *info) {
    fi, err := os.Stat(info.file)
    if os.IsNotExist(err) {
        fmt.Println("skipping (does not exist)", info.file)
        return
    }
    if err != nil {
        log.Fatalf("error stat'ing %s: %v\n", info.file, err)
    }
    content, err := ioutil.ReadFile(info.file)
    if err != nil {
        log.Fatalf("error reading %s: %v\n", info.file, err)
    }
    // Construct new file content.
    buf := new(bytes.Buffer)
    licenseT.Execute(buf, info)
    if m := licenseCommentRE.FindIndex(content); m != nil && m[0] == 0 {
        buf.Write(content[:m[0]])
        buf.Write(content[m[1]:])
    } else {
        buf.Write(content)
    }
    // Write it to the file.
    if bytes.Equal(content, buf.Bytes()) {
        fmt.Println("skipping (no changes)", info.file)
        return
    }
    fmt.Println("writing", info.ShortLicense(), info.file)
    if err := ioutil.WriteFile(info.file, buf.Bytes(), fi.Mode()); err != nil {
        log.Fatalf("error writing %s: %v", info.file, err)
    }
}

func doLines(cmd *exec.Cmd, f func(string)) error {
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        return err
    }
    if err := cmd.Start(); err != nil {
        return err
    }
    s := bufio.NewScanner(stdout)
    for s.Scan() {
        f(s.Text())
    }
    if s.Err() != nil {
        return s.Err()
    }
    if err := cmd.Wait(); err != nil {
        return fmt.Errorf("%v (for %s)", err, strings.Join(cmd.Args, " "))
    }
    return nil
}