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
|
package files
import (
"fmt"
"hash/fnv"
"io"
"io/fs"
"mime"
"os"
"path/filepath"
"strings"
"go.alanpearce.eu/x/log"
"gitlab.com/tozd/go/errors"
)
type File struct {
ContentType string
Etag string
Alternatives map[string]string
}
func (f *File) AvailableEncodings() []string {
encs := []string{}
for enc := range f.Alternatives {
encs = append(encs, enc)
}
return encs
}
type Reader struct {
root string
log *log.Logger
files map[string]*File
}
func NewReader(path string, log *log.Logger) (*Reader, error) {
r := &Reader{
root: path,
log: log,
files: make(map[string]*File),
}
if err := r.registerContentFiles(); err != nil {
return nil, errors.WithMessagef(err, "registering content files")
}
return r, nil
}
func hashFile(filename string) (string, error) {
f, err := os.Open(filename)
if err != nil {
return "", errors.WithMessagef(err, "could not open file %s for hashing", filename)
}
defer f.Close()
hash := fnv.New64a()
if _, err := io.Copy(hash, f); err != nil {
return "", errors.WithMessagef(err, "could not hash file %s", filename)
}
return fmt.Sprintf(`W/"%x"`, hash.Sum(nil)), nil
}
var encodings = map[string]string{
"br": ".br",
"gzip": ".gz",
}
func (r *Reader) registerFile(urlpath string, fp string) error {
hash, err := hashFile(fp)
if err != nil {
return err
}
f := File{
ContentType: mime.TypeByExtension(filepath.Ext(fp)),
Etag: hash,
Alternatives: map[string]string{
"identity": fp,
},
}
for enc, suffix := range encodings {
_, err := os.Stat(fp + suffix)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
continue
}
return err
}
f.Alternatives[enc] = fp + suffix
}
r.files[urlpath] = &f
return nil
}
func (r *Reader) registerContentFiles() error {
err := filepath.WalkDir(r.root, func(filePath string, f fs.DirEntry, err error) error {
if err != nil {
return errors.WithMessagef(err, "failed to access path %s", filePath)
}
relPath, err := filepath.Rel(r.root, filePath)
if err != nil {
return errors.WithMessagef(err, "failed to make path relative, path: %s", filePath)
}
urlPath, _ := strings.CutSuffix("/"+relPath, "index.html")
if !f.IsDir() {
switch filepath.Ext(relPath) {
case ".br", ".gz":
return nil
}
r.log.Debug("registering file", "urlpath", urlPath)
return r.registerFile(urlPath, filePath)
}
return nil
})
if err != nil {
return errors.WithMessage(err, "could not walk directory")
}
return nil
}
func (r *Reader) GetFile(urlPath string) *File {
return r.files[urlPath]
}
func (r *Reader) CanonicalisePath(path string) (cPath string, differs bool) {
cPath = path
if strings.HasSuffix(path, "/index.html") {
cPath, differs = strings.CutSuffix(path, "index.html")
} else if !strings.HasSuffix(path, "/") && r.files[path+"/"] != nil {
cPath, differs = path+"/", true
}
return cPath, differs
}
|