forked from caddyserver/caddy
/
templates.go
129 lines (107 loc) · 3.5 KB
/
templates.go
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
// Package templates implements template execution for files to be
// dynamically rendered for the client.
package templates
import (
"bytes"
"mime"
"net/http"
"path"
"path/filepath"
"strconv"
"strings"
"sync"
"text/template"
"time"
"github.com/mholt/caddy/caddyhttp/httpserver"
)
// ServeHTTP implements the httpserver.Handler interface.
func (t Templates) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
// iterate rules, to find first one that matches the request path
for _, rule := range t.Rules {
if !httpserver.Path(r.URL.Path).Matches(rule.Path) {
continue
}
fpath := r.URL.Path
// get a buffer from the pool and make a response recorder
buf := t.BufPool.Get().(*bytes.Buffer)
buf.Reset()
defer t.BufPool.Put(buf)
// only buffer the response when we want to execute a template
shouldBuf := func(status int, header http.Header) bool {
// see if this request matches a template extension
reqExt := path.Ext(fpath)
for _, ext := range rule.Extensions {
if reqExt == "" {
// request has no extension, so check response Content-Type
ct := mime.TypeByExtension(ext)
if ct != "" && strings.Contains(header.Get("Content-Type"), ct) {
return true
}
} else if reqExt == ext {
return true
}
}
return false
}
// prepare a buffer to hold the response, if applicable
rb := httpserver.NewResponseBuffer(buf, w, shouldBuf)
// pass request up the chain to let another middleware provide us the template
code, err := t.Next.ServeHTTP(rb, r)
if !rb.Buffered() || code >= 300 || err != nil {
return code, err
}
// create a new template
templateName := filepath.Base(fpath)
tpl := template.New(templateName)
// set delimiters
if rule.Delims != [2]string{} {
tpl.Delims(rule.Delims[0], rule.Delims[1])
}
// add custom functions
tpl.Funcs(httpserver.TemplateFuncs)
// parse the template
parsedTpl, err := tpl.Parse(rb.Buffer.String())
if err != nil {
return http.StatusInternalServerError, err
}
// create execution context for the template template
ctx := httpserver.NewContextWithHeader(w.Header())
ctx.Root = t.FileSys
ctx.Req = r
ctx.URL = r.URL
// execute the template
buf.Reset()
err = parsedTpl.Execute(buf, ctx)
if err != nil {
return http.StatusInternalServerError, err
}
// copy the buffered header into the real ResponseWriter
rb.CopyHeader()
// set the actual content length now that the template was executed
w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
// get the modification time in preparation for http.ServeContent
modTime, _ := time.Parse(http.TimeFormat, w.Header().Get("Last-Modified"))
// at last, write the rendered template to the response; make sure to use
// use the proper status code, since ServeContent hard-codes 2xx codes...
http.ServeContent(rb.StatusCodeWriter(w), r, templateName, modTime, bytes.NewReader(buf.Bytes()))
return 0, nil
}
return t.Next.ServeHTTP(w, r)
}
// Templates is middleware to render templated files as the HTTP response.
type Templates struct {
Next httpserver.Handler
Rules []Rule
Root string
FileSys http.FileSystem
BufPool *sync.Pool // docs: "A Pool must not be copied after first use."
}
// Rule represents a template rule. A template will only execute
// with this rule if the request path matches the Path specified
// and requests a resource with one of the extensions specified.
type Rule struct {
Path string
Extensions []string
IndexFiles []string
Delims [2]string
}