2019-06-30 17:07:58 -05:00
|
|
|
// Copyright 2015 Matthew Holt and The Caddy Authors
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
2019-06-18 12:13:12 -05:00
|
|
|
package templates
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"fmt"
|
|
|
|
"net/http"
|
|
|
|
"strconv"
|
2019-06-21 15:36:26 -05:00
|
|
|
"strings"
|
2019-06-18 12:13:12 -05:00
|
|
|
|
2019-07-02 13:37:06 -05:00
|
|
|
"github.com/caddyserver/caddy/v2"
|
|
|
|
"github.com/caddyserver/caddy/v2/modules/caddyhttp"
|
2019-06-18 12:13:12 -05:00
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
2019-08-21 11:46:35 -05:00
|
|
|
caddy.RegisterModule(Templates{})
|
2019-06-18 12:13:12 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Templates is a middleware which execute response bodies as templates.
|
|
|
|
type Templates struct {
|
2019-07-11 18:02:57 -05:00
|
|
|
IncludeRoot string `json:"include_root,omitempty"`
|
|
|
|
MIMETypes []string `json:"mime_types,omitempty"`
|
|
|
|
Delimiters []string `json:"delimiters,omitempty"`
|
2019-06-18 12:13:12 -05:00
|
|
|
}
|
|
|
|
|
2019-08-21 11:46:35 -05:00
|
|
|
// CaddyModule returns the Caddy module information.
|
|
|
|
func (Templates) CaddyModule() caddy.ModuleInfo {
|
|
|
|
return caddy.ModuleInfo{
|
2019-12-10 15:36:46 -05:00
|
|
|
ID: "http.handlers.templates",
|
|
|
|
New: func() caddy.Module { return new(Templates) },
|
2019-08-21 11:46:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 14:09:10 -05:00
|
|
|
// Provision provisions t.
|
|
|
|
func (t *Templates) Provision(ctx caddy.Context) error {
|
|
|
|
if t.MIMETypes == nil {
|
|
|
|
t.MIMETypes = defaultMIMETypes
|
|
|
|
}
|
2019-09-06 13:36:45 -05:00
|
|
|
if t.IncludeRoot == "" {
|
|
|
|
t.IncludeRoot = "{http.vars.root}"
|
|
|
|
}
|
2019-06-27 14:09:10 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-18 12:13:12 -05:00
|
|
|
// Validate ensures t has a valid configuration.
|
|
|
|
func (t *Templates) Validate() error {
|
|
|
|
if len(t.Delimiters) != 0 && len(t.Delimiters) != 2 {
|
|
|
|
return fmt.Errorf("delimiters must consist of exactly two elements: opening and closing")
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Templates) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyhttp.Handler) error {
|
|
|
|
buf := bufPool.Get().(*bytes.Buffer)
|
|
|
|
buf.Reset()
|
|
|
|
defer bufPool.Put(buf)
|
|
|
|
|
2019-06-27 14:09:10 -05:00
|
|
|
// shouldBuf determines whether to execute templates on this response,
|
|
|
|
// since generally we will not want to execute for images or CSS, etc.
|
2019-10-15 15:07:10 -05:00
|
|
|
shouldBuf := func(status int, header http.Header) bool {
|
|
|
|
ct := header.Get("Content-Type")
|
2019-06-27 14:09:10 -05:00
|
|
|
for _, mt := range t.MIMETypes {
|
|
|
|
if strings.Contains(ct, mt) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
2019-06-21 15:36:26 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
rec := caddyhttp.NewResponseRecorder(w, buf, shouldBuf)
|
2019-06-18 12:13:12 -05:00
|
|
|
|
2019-06-21 15:36:26 -05:00
|
|
|
err := next.ServeHTTP(rec, r)
|
2019-06-18 12:13:12 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-06-21 15:36:26 -05:00
|
|
|
if !rec.Buffered() {
|
|
|
|
return nil
|
|
|
|
}
|
2019-06-18 12:13:12 -05:00
|
|
|
|
2019-06-21 15:36:26 -05:00
|
|
|
err = t.executeTemplate(rec, r)
|
2019-06-18 12:13:12 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-10-15 15:07:10 -05:00
|
|
|
rec.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
|
|
|
|
rec.Header().Del("Accept-Ranges") // we don't know ranges for dynamically-created content
|
|
|
|
rec.Header().Del("Last-Modified") // useless for dynamic content since it's always changing
|
2019-06-18 12:13:12 -05:00
|
|
|
|
2019-06-27 14:09:10 -05:00
|
|
|
// we don't know a way to guickly generate etag for dynamic content,
|
|
|
|
// but we can convert this to a weak etag to kind of indicate that
|
2019-10-15 15:07:10 -05:00
|
|
|
if etag := rec.Header().Get("Etag"); etag != "" {
|
|
|
|
rec.Header().Set("Etag", "W/"+etag)
|
2019-06-27 14:09:10 -05:00
|
|
|
}
|
|
|
|
|
2019-10-15 15:07:10 -05:00
|
|
|
rec.WriteResponse()
|
2019-06-18 12:13:12 -05:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-20 22:49:45 -05:00
|
|
|
// executeTemplate executes the template contained in wb.buf and replaces it with the results.
|
|
|
|
func (t *Templates) executeTemplate(rr caddyhttp.ResponseRecorder, r *http.Request) error {
|
2019-06-18 12:13:12 -05:00
|
|
|
var fs http.FileSystem
|
2019-07-11 18:02:57 -05:00
|
|
|
if t.IncludeRoot != "" {
|
2019-08-09 13:05:47 -05:00
|
|
|
repl := r.Context().Value(caddy.ReplacerCtxKey).(caddy.Replacer)
|
|
|
|
fs = http.Dir(repl.ReplaceAll(t.IncludeRoot, "."))
|
2019-06-18 12:13:12 -05:00
|
|
|
}
|
2019-06-18 16:17:48 -05:00
|
|
|
|
2019-06-18 12:13:12 -05:00
|
|
|
ctx := &templateContext{
|
|
|
|
Root: fs,
|
|
|
|
Req: r,
|
2019-06-20 22:49:45 -05:00
|
|
|
RespHeader: tplWrappedHeader{rr.Header()},
|
2019-06-18 16:17:48 -05:00
|
|
|
config: t,
|
2019-06-18 12:13:12 -05:00
|
|
|
}
|
|
|
|
|
2019-06-20 22:49:45 -05:00
|
|
|
err := ctx.executeTemplateInBuffer(r.URL.Path, rr.Buffer())
|
2019-06-18 12:13:12 -05:00
|
|
|
if err != nil {
|
|
|
|
return caddyhttp.Error(http.StatusInternalServerError, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-20 22:49:45 -05:00
|
|
|
// virtualResponseWriter is used in virtualized HTTP requests
|
|
|
|
// that templates may execute.
|
2019-06-18 12:13:12 -05:00
|
|
|
type virtualResponseWriter struct {
|
|
|
|
status int
|
|
|
|
header http.Header
|
|
|
|
body *bytes.Buffer
|
|
|
|
}
|
|
|
|
|
|
|
|
func (vrw *virtualResponseWriter) Header() http.Header {
|
|
|
|
return vrw.header
|
|
|
|
}
|
|
|
|
|
|
|
|
func (vrw *virtualResponseWriter) WriteHeader(statusCode int) {
|
|
|
|
vrw.status = statusCode
|
|
|
|
}
|
|
|
|
|
|
|
|
func (vrw *virtualResponseWriter) Write(data []byte) (int, error) {
|
|
|
|
return vrw.body.Write(data)
|
|
|
|
}
|
|
|
|
|
2019-06-27 14:09:10 -05:00
|
|
|
var defaultMIMETypes = []string{
|
|
|
|
"text/html",
|
|
|
|
"text/plain",
|
|
|
|
"text/markdown",
|
|
|
|
}
|
|
|
|
|
2019-06-18 12:13:12 -05:00
|
|
|
// Interface guards
|
|
|
|
var (
|
2019-06-27 14:09:10 -05:00
|
|
|
_ caddy.Provisioner = (*Templates)(nil)
|
2019-06-18 12:13:12 -05:00
|
|
|
_ caddy.Validator = (*Templates)(nil)
|
|
|
|
_ caddyhttp.MiddlewareHandler = (*Templates)(nil)
|
|
|
|
)
|