1package vfsgen
2
3import (
4 "bytes"
5 "compress/gzip"
6 "errors"
7 "fmt"
8 "io"
9 "io/ioutil"
10 "log"
11 "net/http"
12 "os"
13 pathpkg "path"
14 "sort"
15 "strconv"
16 "text/template"
17 "time"
18
19 "github.com/shurcooL/httpfs/vfsutil"
20)
21
22// Generate Go code that statically implements input filesystem,
23// write the output to a file specified in opt.
24func Generate(input http.FileSystem, opt Options) error {
25 opt.fillMissing()
26
27 // Use an in-memory buffer to generate the entire output.
28 buf := new(bytes.Buffer)
29
30 err := t.ExecuteTemplate(buf, "Header", opt)
31 if err != nil {
32 return err
33 }
34
35 var toc toc
36 err = findAndWriteFiles(buf, input, &toc)
37 if err != nil {
38 return err
39 }
40
41 err = t.ExecuteTemplate(buf, "DirEntries", toc.dirs)
42 if err != nil {
43 return err
44 }
45
46 err = t.ExecuteTemplate(buf, "Trailer", toc)
47 if err != nil {
48 return err
49 }
50
51 // Write output file (all at once).
52 fmt.Println("writing", opt.Filename)
53 err = ioutil.WriteFile(opt.Filename, buf.Bytes(), 0644)
54 return err
55}
56
57type toc struct {
58 dirs []*dirInfo
59
60 HasCompressedFile bool // There's at least one compressedFile.
61 HasFile bool // There's at least one uncompressed file.
62}
63
64// fileInfo is a definition of a file.
65type fileInfo struct {
66 Path string
67 Name string
68 ModTime time.Time
69 UncompressedSize int64
70}
71
72// dirInfo is a definition of a directory.
73type dirInfo struct {
74 Path string
75 Name string
76 ModTime time.Time
77 Entries []string
78}
79
80// findAndWriteFiles recursively finds all the file paths in the given directory tree.
81// They are added to the given map as keys. Values will be safe function names
82// for each file, which will be used when generating the output code.
83func findAndWriteFiles(buf *bytes.Buffer, fs http.FileSystem, toc *toc) error {
84 walkFn := func(path string, fi os.FileInfo, r io.ReadSeeker, err error) error {
85 if err != nil {
86 log.Printf("can't stat file %q: %v\n", path, err)
87 return nil
88 }
89
90 switch fi.IsDir() {
91 case false:
92 file := &fileInfo{
93 Path: path,
94 Name: pathpkg.Base(path),
95 ModTime: fi.ModTime().UTC(),
96 UncompressedSize: fi.Size(),
97 }
98
99 marker := buf.Len()
100
101 // Write CompressedFileInfo.
102 err = writeCompressedFileInfo(buf, file, r)
103 switch err {
104 default:
105 return err
106 case nil:
107 toc.HasCompressedFile = true
108 // If compressed file is not smaller than original, revert and write original file.
109 case errCompressedNotSmaller:
110 _, err = r.Seek(0, io.SeekStart)
111 if err != nil {
112 return err
113 }
114
115 buf.Truncate(marker)
116
117 // Write FileInfo.
118 err = writeFileInfo(buf, file, r)
119 if err != nil {
120 return err
121 }
122 toc.HasFile = true
123 }
124 case true:
125 entries, err := readDirPaths(fs, path)
126 if err != nil {
127 return err
128 }
129
130 dir := &dirInfo{
131 Path: path,
132 Name: pathpkg.Base(path),
133 ModTime: fi.ModTime().UTC(),
134 Entries: entries,
135 }
136
137 toc.dirs = append(toc.dirs, dir)
138
139 // Write DirInfo.
140 err = t.ExecuteTemplate(buf, "DirInfo", dir)
141 if err != nil {
142 return err
143 }
144 }
145
146 return nil
147 }
148
149 err := vfsutil.WalkFiles(fs, "/", walkFn)
150 return err
151}
152
153// readDirPaths reads the directory named by dirname and returns
154// a sorted list of directory paths.
155func readDirPaths(fs http.FileSystem, dirname string) ([]string, error) {
156 fis, err := vfsutil.ReadDir(fs, dirname)
157 if err != nil {
158 return nil, err
159 }
160 paths := make([]string, len(fis))
161 for i := range fis {
162 paths[i] = pathpkg.Join(dirname, fis[i].Name())
163 }
164 sort.Strings(paths)
165 return paths, nil
166}
167
168// writeCompressedFileInfo writes CompressedFileInfo.
169// It returns errCompressedNotSmaller if compressed file is not smaller than original.
170func writeCompressedFileInfo(w io.Writer, file *fileInfo, r io.Reader) error {
171 err := t.ExecuteTemplate(w, "CompressedFileInfo-Before", file)
172 if err != nil {
173 return err
174 }
175 sw := &stringWriter{Writer: w}
176 gw := gzip.NewWriter(sw)
177 _, err = io.Copy(gw, r)
178 if err != nil {
179 return err
180 }
181 err = gw.Close()
182 if err != nil {
183 return err
184 }
185 if sw.N >= file.UncompressedSize {
186 return errCompressedNotSmaller
187 }
188 err = t.ExecuteTemplate(w, "CompressedFileInfo-After", file)
189 return err
190}
191
192var errCompressedNotSmaller = errors.New("compressed file is not smaller than original")
193
194// Write FileInfo.
195func writeFileInfo(w io.Writer, file *fileInfo, r io.Reader) error {
196 err := t.ExecuteTemplate(w, "FileInfo-Before", file)
197 if err != nil {
198 return err
199 }
200 sw := &stringWriter{Writer: w}
201 _, err = io.Copy(sw, r)
202 if err != nil {
203 return err
204 }
205 err = t.ExecuteTemplate(w, "FileInfo-After", file)
206 return err
207}
208
209var t = template.Must(template.New("").Funcs(template.FuncMap{
210 "quote": strconv.Quote,
211 "comment": func(s string) (string, error) {
212 var buf bytes.Buffer
213 cw := &commentWriter{W: &buf}
214 _, err := io.WriteString(cw, s)
215 if err != nil {
216 return "", err
217 }
218 err = cw.Close()
219 return buf.String(), err
220 },
221}).Parse(`{{define "Header"}}// Code generated by vfsgen; DO NOT EDIT.
222
223{{with .BuildTags}}// +build {{.}}
224
225{{end}}package {{.PackageName}}
226
227import (
228 "bytes"
229 "compress/gzip"
230 "fmt"
231 "io"
232 "io/ioutil"
233 "net/http"
234 "os"
235 pathpkg "path"
236 "time"
237)
238
239{{comment .VariableComment}}
240var {{.VariableName}} = func() http.FileSystem {
241 fs := vfsgen۰FS{
242{{end}}
243
244
245
246{{define "CompressedFileInfo-Before"}} {{quote .Path}}: &vfsgen۰CompressedFileInfo{
247 name: {{quote .Name}},
248 modTime: {{template "Time" .ModTime}},
249 uncompressedSize: {{.UncompressedSize}},
250{{/* This blank line separating compressedContent is neccessary to prevent potential gofmt issues. See issue #19. */}}
251 compressedContent: []byte("{{end}}{{define "CompressedFileInfo-After"}}"),
252 },
253{{end}}
254
255
256
257{{define "FileInfo-Before"}} {{quote .Path}}: &vfsgen۰FileInfo{
258 name: {{quote .Name}},
259 modTime: {{template "Time" .ModTime}},
260 content: []byte("{{end}}{{define "FileInfo-After"}}"),
261 },
262{{end}}
263
264
265
266{{define "DirInfo"}} {{quote .Path}}: &vfsgen۰DirInfo{
267 name: {{quote .Name}},
268 modTime: {{template "Time" .ModTime}},
269 },
270{{end}}
271
272
273
274{{define "DirEntries"}} }
275{{range .}}{{if .Entries}} fs[{{quote .Path}}].(*vfsgen۰DirInfo).entries = []os.FileInfo{{"{"}}{{range .Entries}}
276 fs[{{quote .}}].(os.FileInfo),{{end}}
277 }
278{{end}}{{end}}
279 return fs
280}()
281{{end}}
282
283
284
285{{define "Trailer"}}
286type vfsgen۰FS map[string]interface{}
287
288func (fs vfsgen۰FS) Open(path string) (http.File, error) {
289 path = pathpkg.Clean("/" + path)
290 f, ok := fs[path]
291 if !ok {
292 return nil, &os.PathError{Op: "open", Path: path, Err: os.ErrNotExist}
293 }
294
295 switch f := f.(type) {{"{"}}{{if .HasCompressedFile}}
296 case *vfsgen۰CompressedFileInfo:
297 gr, err := gzip.NewReader(bytes.NewReader(f.compressedContent))
298 if err != nil {
299 // This should never happen because we generate the gzip bytes such that they are always valid.
300 panic("unexpected error reading own gzip compressed bytes: " + err.Error())
301 }
302 return &vfsgen۰CompressedFile{
303 vfsgen۰CompressedFileInfo: f,
304 gr: gr,
305 }, nil{{end}}{{if .HasFile}}
306 case *vfsgen۰FileInfo:
307 return &vfsgen۰File{
308 vfsgen۰FileInfo: f,
309 Reader: bytes.NewReader(f.content),
310 }, nil{{end}}
311 case *vfsgen۰DirInfo:
312 return &vfsgen۰Dir{
313 vfsgen۰DirInfo: f,
314 }, nil
315 default:
316 // This should never happen because we generate only the above types.
317 panic(fmt.Sprintf("unexpected type %T", f))
318 }
319}
320{{if .HasCompressedFile}}
321// vfsgen۰CompressedFileInfo is a static definition of a gzip compressed file.
322type vfsgen۰CompressedFileInfo struct {
323 name string
324 modTime time.Time
325 compressedContent []byte
326 uncompressedSize int64
327}
328
329func (f *vfsgen۰CompressedFileInfo) Readdir(count int) ([]os.FileInfo, error) {
330 return nil, fmt.Errorf("cannot Readdir from file %s", f.name)
331}
332func (f *vfsgen۰CompressedFileInfo) Stat() (os.FileInfo, error) { return f, nil }
333
334func (f *vfsgen۰CompressedFileInfo) GzipBytes() []byte {
335 return f.compressedContent
336}
337
338func (f *vfsgen۰CompressedFileInfo) Name() string { return f.name }
339func (f *vfsgen۰CompressedFileInfo) Size() int64 { return f.uncompressedSize }
340func (f *vfsgen۰CompressedFileInfo) Mode() os.FileMode { return 0444 }
341func (f *vfsgen۰CompressedFileInfo) ModTime() time.Time { return f.modTime }
342func (f *vfsgen۰CompressedFileInfo) IsDir() bool { return false }
343func (f *vfsgen۰CompressedFileInfo) Sys() interface{} { return nil }
344
345// vfsgen۰CompressedFile is an opened compressedFile instance.
346type vfsgen۰CompressedFile struct {
347 *vfsgen۰CompressedFileInfo
348 gr *gzip.Reader
349 grPos int64 // Actual gr uncompressed position.
350 seekPos int64 // Seek uncompressed position.
351}
352
353func (f *vfsgen۰CompressedFile) Read(p []byte) (n int, err error) {
354 if f.grPos > f.seekPos {
355 // Rewind to beginning.
356 err = f.gr.Reset(bytes.NewReader(f.compressedContent))
357 if err != nil {
358 return 0, err
359 }
360 f.grPos = 0
361 }
362 if f.grPos < f.seekPos {
363 // Fast-forward.
364 _, err = io.CopyN(ioutil.Discard, f.gr, f.seekPos-f.grPos)
365 if err != nil {
366 return 0, err
367 }
368 f.grPos = f.seekPos
369 }
370 n, err = f.gr.Read(p)
371 f.grPos += int64(n)
372 f.seekPos = f.grPos
373 return n, err
374}
375func (f *vfsgen۰CompressedFile) Seek(offset int64, whence int) (int64, error) {
376 switch whence {
377 case io.SeekStart:
378 f.seekPos = 0 + offset
379 case io.SeekCurrent:
380 f.seekPos += offset
381 case io.SeekEnd:
382 f.seekPos = f.uncompressedSize + offset
383 default:
384 panic(fmt.Errorf("invalid whence value: %v", whence))
385 }
386 return f.seekPos, nil
387}
388func (f *vfsgen۰CompressedFile) Close() error {
389 return f.gr.Close()
390}
391{{else}}
392// We already imported "compress/gzip" and "io/ioutil", but ended up not using them. Avoid unused import error.
393var _ = gzip.Reader{}
394var _ = ioutil.Discard
395{{end}}{{if .HasFile}}
396// vfsgen۰FileInfo is a static definition of an uncompressed file (because it's not worth gzip compressing).
397type vfsgen۰FileInfo struct {
398 name string
399 modTime time.Time
400 content []byte
401}
402
403func (f *vfsgen۰FileInfo) Readdir(count int) ([]os.FileInfo, error) {
404 return nil, fmt.Errorf("cannot Readdir from file %s", f.name)
405}
406func (f *vfsgen۰FileInfo) Stat() (os.FileInfo, error) { return f, nil }
407
408func (f *vfsgen۰FileInfo) NotWorthGzipCompressing() {}
409
410func (f *vfsgen۰FileInfo) Name() string { return f.name }
411func (f *vfsgen۰FileInfo) Size() int64 { return int64(len(f.content)) }
412func (f *vfsgen۰FileInfo) Mode() os.FileMode { return 0444 }
413func (f *vfsgen۰FileInfo) ModTime() time.Time { return f.modTime }
414func (f *vfsgen۰FileInfo) IsDir() bool { return false }
415func (f *vfsgen۰FileInfo) Sys() interface{} { return nil }
416
417// vfsgen۰File is an opened file instance.
418type vfsgen۰File struct {
419 *vfsgen۰FileInfo
420 *bytes.Reader
421}
422
423func (f *vfsgen۰File) Close() error {
424 return nil
425}
426{{else if not .HasCompressedFile}}
427// We already imported "bytes", but ended up not using it. Avoid unused import error.
428var _ = bytes.Reader{}
429{{end}}
430// vfsgen۰DirInfo is a static definition of a directory.
431type vfsgen۰DirInfo struct {
432 name string
433 modTime time.Time
434 entries []os.FileInfo
435}
436
437func (d *vfsgen۰DirInfo) Read([]byte) (int, error) {
438 return 0, fmt.Errorf("cannot Read from directory %s", d.name)
439}
440func (d *vfsgen۰DirInfo) Close() error { return nil }
441func (d *vfsgen۰DirInfo) Stat() (os.FileInfo, error) { return d, nil }
442
443func (d *vfsgen۰DirInfo) Name() string { return d.name }
444func (d *vfsgen۰DirInfo) Size() int64 { return 0 }
445func (d *vfsgen۰DirInfo) Mode() os.FileMode { return 0755 | os.ModeDir }
446func (d *vfsgen۰DirInfo) ModTime() time.Time { return d.modTime }
447func (d *vfsgen۰DirInfo) IsDir() bool { return true }
448func (d *vfsgen۰DirInfo) Sys() interface{} { return nil }
449
450// vfsgen۰Dir is an opened dir instance.
451type vfsgen۰Dir struct {
452 *vfsgen۰DirInfo
453 pos int // Position within entries for Seek and Readdir.
454}
455
456func (d *vfsgen۰Dir) Seek(offset int64, whence int) (int64, error) {
457 if offset == 0 && whence == io.SeekStart {
458 d.pos = 0
459 return 0, nil
460 }
461 return 0, fmt.Errorf("unsupported Seek in directory %s", d.name)
462}
463
464func (d *vfsgen۰Dir) Readdir(count int) ([]os.FileInfo, error) {
465 if d.pos >= len(d.entries) && count > 0 {
466 return nil, io.EOF
467 }
468 if count <= 0 || count > len(d.entries)-d.pos {
469 count = len(d.entries) - d.pos
470 }
471 e := d.entries[d.pos : d.pos+count]
472 d.pos += count
473 return e, nil
474}
475{{end}}
476
477
478
479{{define "Time"}}
480{{- if .IsZero -}}
481 time.Time{}
482{{- else -}}
483 time.Date({{.Year}}, {{printf "%d" .Month}}, {{.Day}}, {{.Hour}}, {{.Minute}}, {{.Second}}, {{.Nanosecond}}, time.UTC)
484{{- end -}}
485{{end}}
486`))