file1.html",
+ filepath.Join("dirwithindex", "index.html"): "dirwithindex/index.html
",
+ filepath.Join("dir", "file2.html"): "dir/file2.html
",
+ filepath.Join("dir", "hidden.html"): "dir/hidden.html
",
+}
+
+// TestServeHTTP covers positive scenarios when serving files.
+func TestServeHTTP(t *testing.T) {
+
+ beforeServeHttpTest(t)
+ defer afterServeHttpTest(t)
+
+ fileserver := FileServer(http.Dir(testDir), []string{"hidden.html"})
+
+ movedPermanently := "Moved Permanently"
+
+ tests := []struct {
+ url string
+
+ expectedStatus int
+ expectedBodyContent string
+ }{
+ // Test 0 - access withoutt any path
+ {
+ url: "https://foo",
+ expectedStatus: http.StatusNotFound,
+ },
+ // Test 1 - access root (without index.html)
+ {
+ url: "https://foo/",
+ expectedStatus: http.StatusNotFound,
+ },
+ // Test 2 - access existing file
+ {
+ url: "https://foo/file1.html",
+ expectedStatus: http.StatusOK,
+ expectedBodyContent: testFiles["file1.html"],
+ },
+ // Test 3 - access folder with index file with trailing slash
+ {
+ url: "https://foo/dirwithindex/",
+ expectedStatus: http.StatusOK,
+ expectedBodyContent: testFiles[filepath.Join("dirwithindex", "index.html")],
+ },
+ // Test 4 - access folder with index file without trailing slash
+ {
+ url: "https://foo/dirwithindex",
+ expectedStatus: http.StatusMovedPermanently,
+ expectedBodyContent: movedPermanently,
+ },
+ // Test 5 - access folder without index file
+ {
+ url: "https://foo/dir/",
+ expectedStatus: http.StatusNotFound,
+ },
+ // Test 6 - access folder withtout trailing slash
+ {
+ url: "https://foo/dir",
+ expectedStatus: http.StatusMovedPermanently,
+ expectedBodyContent: movedPermanently,
+ },
+ // Test 6 - access file with trailing slash
+ {
+ url: "https://foo/file1.html/",
+ expectedStatus: http.StatusMovedPermanently,
+ expectedBodyContent: movedPermanently,
+ },
+ // Test 7 - access not existing path
+ {
+ url: "https://foo/not_existing",
+ expectedStatus: http.StatusNotFound,
+ },
+ // Test 8 - access a file, marked as hidden
+ {
+ url: "https://foo/dir/hidden.html",
+ expectedStatus: http.StatusNotFound,
+ },
+ // Test 9 - access a index file directly
+ {
+ url: "https://foo/dirwithindex/index.html",
+ expectedStatus: http.StatusOK,
+ expectedBodyContent: testFiles[filepath.Join("dirwithindex", "index.html")],
+ },
+ // Test 10 - send a request with query params
+ {
+ url: "https://foo/dir?param1=val",
+ expectedStatus: http.StatusMovedPermanently,
+ expectedBodyContent: movedPermanently,
+ },
+ }
+
+ for i, test := range tests {
+ responseRecorder := httptest.NewRecorder()
+ request, err := http.NewRequest("GET", test.url, strings.NewReader(""))
+ status, err := fileserver.ServeHTTP(responseRecorder, request)
+
+ // check if error matches expectations
+ if err != nil {
+ t.Errorf(getTestPrefix(i)+"Serving file at %s failed. Error was: %v", test.url, err)
+ }
+
+ // check status code
+ if test.expectedStatus != status {
+ t.Errorf(getTestPrefix(i)+"Expected status %d, found %d", test.expectedStatus, status)
+ }
+
+ // check body content
+ if !strings.Contains(responseRecorder.Body.String(), test.expectedBodyContent) {
+ t.Errorf(getTestPrefix(i)+"Expected body to contain %q, found %q", test.expectedBodyContent, responseRecorder.Body.String())
+ }
+ }
+
+}
+
+// beforeServeHttpTest creates a test directory with the structure, defined in the variable testFiles
+func beforeServeHttpTest(t *testing.T) {
+ // make the root test dir
+ err := os.Mkdir(testDir, os.ModePerm)
+ if err != nil {
+ if !os.IsExist(err) {
+ t.Fatalf("Failed to create test dir. Error was: %v", err)
+ return
+ }
+ }
+
+ for relFile, fileContent := range testFiles {
+ absFile := filepath.Join(testDir, relFile)
+
+ // make sure the parent directories exist
+ parentDir := filepath.Dir(absFile)
+ _, err = os.Stat(parentDir)
+ if err != nil {
+ os.MkdirAll(parentDir, os.ModePerm)
+ }
+
+ // now create the test files
+ f, err := os.Create(absFile)
+ if err != nil {
+ t.Fatalf("Failed to create test file %s. Error was: %v", absFile, err)
+ return
+ }
+
+ // and fill them with content
+ _, err = f.WriteString(fileContent)
+ if err != nil {
+ t.Fatalf("Failed to write to %s. Error was: %v", absFile, err)
+ return
+ }
+ f.Close()
+ }
+
+}
+
+// afterServeHttpTest removes the test dir and all its content
+func afterServeHttpTest(t *testing.T) {
+ // cleans up everything under the test dir. No need to clean the individual files.
+ err := os.RemoveAll(testDir)
+ if err != nil {
+ t.Fatalf("Failed to clean up test dir %s. Error was: %v", testDir, err)
+ }
+}
+
+// failingFS implements the http.FileSystem interface. The Open method always returns the error, assigned to err
+type failingFS struct {
+ err error // the error to return when Open is called
+ fileImpl http.File // inject the file implementation
+}
+
+// Open returns the assigned failingFile and error
+func (f failingFS) Open(path string) (http.File, error) {
+ return f.fileImpl, f.err
+}
+
+// failingFile implements http.File but returns a predefined error on every Stat() method call.
+type failingFile struct {
+ http.File
+ err error
+}
+
+// Stat returns nil FileInfo and the provided error on every call
+func (ff failingFile) Stat() (os.FileInfo, error) {
+ return nil, ff.err
+}
+
+// Close is noop and returns no error
+func (ff failingFile) Close() error {
+ return nil
+}
+
+// TestServeHTTPFailingFS tests error cases where the Open function fails with various errors.
+func TestServeHTTPFailingFS(t *testing.T) {
+
+ tests := []struct {
+ fsErr error
+ expectedStatus int
+ expectedErr error
+ expectedHeaders map[string]string
+ }{
+ {
+ fsErr: os.ErrNotExist,
+ expectedStatus: http.StatusNotFound,
+ expectedErr: nil,
+ },
+ {
+ fsErr: os.ErrPermission,
+ expectedStatus: http.StatusForbidden,
+ expectedErr: os.ErrPermission,
+ },
+ {
+ fsErr: customErr,
+ expectedStatus: http.StatusServiceUnavailable,
+ expectedErr: customErr,
+ expectedHeaders: map[string]string{"Retry-After": "5"},
+ },
+ }
+
+ for i, test := range tests {
+ // initialize a file server with the failing FileSystem
+ fileserver := FileServer(failingFS{err: test.fsErr}, nil)
+
+ // prepare the request and response
+ request, err := http.NewRequest("GET", "https://foo/", nil)
+ if err != nil {
+ t.Fatalf("Failed to build request. Error was: %v", err)
+ }
+ responseRecorder := httptest.NewRecorder()
+
+ status, actualErr := fileserver.ServeHTTP(responseRecorder, request)
+
+ // check the status
+ if status != test.expectedStatus {
+ t.Errorf(getTestPrefix(i)+"Expected status %d, found %d", test.expectedStatus, status)
+ }
+
+ // check the error
+ if actualErr != test.expectedErr {
+ t.Errorf(getTestPrefix(i)+"Expected err %v, found %v", test.expectedErr, actualErr)
+ }
+
+ // check the headers - a special case for server under load
+ if test.expectedHeaders != nil && len(test.expectedHeaders) > 0 {
+ for expectedKey, expectedVal := range test.expectedHeaders {
+ actualVal := responseRecorder.Header().Get(expectedKey)
+ if expectedVal != actualVal {
+ t.Errorf(getTestPrefix(i)+"Expected header %s: %s, found %s", expectedKey, expectedVal, actualVal)
+ }
+ }
+ }
+ }
+}
+
+// TestServeHTTPFailingStat tests error cases where the initial Open function succeeds, but the Stat method on the opened file fails.
+func TestServeHTTPFailingStat(t *testing.T) {
+
+ tests := []struct {
+ statErr error
+ expectedStatus int
+ expectedErr error
+ }{
+ {
+ statErr: os.ErrNotExist,
+ expectedStatus: http.StatusNotFound,
+ expectedErr: nil,
+ },
+ {
+ statErr: os.ErrPermission,
+ expectedStatus: http.StatusForbidden,
+ expectedErr: os.ErrPermission,
+ },
+ {
+ statErr: customErr,
+ expectedStatus: http.StatusInternalServerError,
+ expectedErr: customErr,
+ },
+ }
+
+ for i, test := range tests {
+ // initialize a file server. The FileSystem will not fail, but calls to the Stat method of the returned File object will
+ fileserver := FileServer(failingFS{err: nil, fileImpl: failingFile{err: test.statErr}}, nil)
+
+ // prepare the request and response
+ request, err := http.NewRequest("GET", "https://foo/", nil)
+ if err != nil {
+ t.Fatalf("Failed to build request. Error was: %v", err)
+ }
+ responseRecorder := httptest.NewRecorder()
+
+ status, actualErr := fileserver.ServeHTTP(responseRecorder, request)
+
+ // check the status
+ if status != test.expectedStatus {
+ t.Errorf(getTestPrefix(i)+"Expected status %d, found %d", test.expectedStatus, status)
+ }
+
+ // check the error
+ if actualErr != test.expectedErr {
+ t.Errorf(getTestPrefix(i)+"Expected err %v, found %v", test.expectedErr, actualErr)
+ }
+ }
+}
diff --git a/middleware/markdown/generator.go b/middleware/markdown/generator.go
index a02cb3b05..9db82bdcf 100644
--- a/middleware/markdown/generator.go
+++ b/middleware/markdown/generator.go
@@ -17,18 +17,18 @@ import (
// It only generates static files if it is enabled (cfg.StaticDir
// must be set).
func GenerateStatic(md Markdown, cfg *Config) error {
- generated, err := generateLinks(md, cfg)
- if err != nil {
- return err
- }
-
- // No new file changes, return.
- if !generated {
- return nil
- }
-
// If static site generation is enabled.
if cfg.StaticDir != "" {
+ generated, err := generateLinks(md, cfg)
+ if err != nil {
+ return err
+ }
+
+ // No new file changes, return.
+ if !generated {
+ return nil
+ }
+
if err := generateStaticHTML(md, cfg); err != nil {
return err
}
diff --git a/middleware/markdown/markdown.go b/middleware/markdown/markdown.go
index bdf142cf2..3b3bc96e0 100644
--- a/middleware/markdown/markdown.go
+++ b/middleware/markdown/markdown.go
@@ -136,6 +136,7 @@ func (md Markdown) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error
// generation, serve the static page
if fs.ModTime().Before(fs1.ModTime()) {
if html, err := ioutil.ReadFile(filepath); err == nil {
+ middleware.SetLastModifiedHeader(w, fs1.ModTime())
w.Write(html)
return http.StatusOK, nil
}
@@ -162,6 +163,7 @@ func (md Markdown) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error
return http.StatusInternalServerError, err
}
+ middleware.SetLastModifiedHeader(w, fs.ModTime())
w.Write(html)
return http.StatusOK, nil
}
diff --git a/middleware/markdown/markdown_test.go b/middleware/markdown/markdown_test.go
index 8cb89fae5..fbbe845d7 100644
--- a/middleware/markdown/markdown_test.go
+++ b/middleware/markdown/markdown_test.go
@@ -92,7 +92,7 @@ func TestMarkdown(t *testing.T) {
expectedBody := `
-Markdown test
+Markdown test 1
Header
@@ -102,11 +102,10 @@ Welcome to A Caddy website!
Body
-go
-func getTrue() bool {
+func getTrue() bool {
return true
}
-
+
@@ -129,7 +128,7 @@ func getTrue() bool {
expectedBody = `
- Markdown test
+ Markdown test 2
@@ -143,11 +142,10 @@ func getTrue() bool {
Body
-go
-func getTrue() bool {
+func getTrue() bool {
return true
}
-
+
`
diff --git a/middleware/markdown/process.go b/middleware/markdown/process.go
index 0fb48dba1..65f22d66d 100644
--- a/middleware/markdown/process.go
+++ b/middleware/markdown/process.go
@@ -65,7 +65,8 @@ func (md Markdown) Process(c *Config, requestPath string, b []byte, ctx middlewa
}
// process markdown
- markdown = blackfriday.Markdown(markdown, c.Renderer, 0)
+ extns := blackfriday.EXTENSION_TABLES | blackfriday.EXTENSION_FENCED_CODE | blackfriday.EXTENSION_STRIKETHROUGH
+ markdown = blackfriday.Markdown(markdown, c.Renderer, extns)
// set it as body for template
metadata.Variables["body"] = string(markdown)
diff --git a/middleware/markdown/testdata/blog/test.md b/middleware/markdown/testdata/blog/test.md
index 3d33ad918..93f07a493 100644
--- a/middleware/markdown/testdata/blog/test.md
+++ b/middleware/markdown/testdata/blog/test.md
@@ -1,5 +1,5 @@
---
-title: Markdown test
+title: Markdown test 1
sitename: A Caddy website
---
diff --git a/middleware/markdown/testdata/log/test.md b/middleware/markdown/testdata/log/test.md
index 3d33ad918..476ab3015 100644
--- a/middleware/markdown/testdata/log/test.md
+++ b/middleware/markdown/testdata/log/test.md
@@ -1,5 +1,5 @@
---
-title: Markdown test
+title: Markdown test 2
sitename: A Caddy website
---
diff --git a/middleware/middleware.go b/middleware/middleware.go
index ba7699ce4..b88b24474 100644
--- a/middleware/middleware.go
+++ b/middleware/middleware.go
@@ -4,6 +4,7 @@ package middleware
import (
"net/http"
"path"
+ "time"
)
type (
@@ -78,3 +79,30 @@ func IndexFile(root http.FileSystem, fpath string, indexFiles []string) (string,
}
return "", false
}
+
+// SetLastModifiedHeader checks if the provided modTime is valid and if it is sets it
+// as a Last-Modified header to the ResponseWriter. If the modTime is in the future
+// the current time is used instead.
+func SetLastModifiedHeader(w http.ResponseWriter, modTime time.Time) {
+ if modTime.IsZero() || modTime.Equal(time.Unix(0, 0)) {
+ // the time does not appear to be valid. Don't put it in the response
+ return
+ }
+
+ // RFC 2616 - Section 14.29 - Last-Modified:
+ // An origin server MUST NOT send a Last-Modified date which is later than the
+ // server's time of message origination. In such cases, where the resource's last
+ // modification would indicate some time in the future, the server MUST replace
+ // that date with the message origination date.
+ now := currentTime()
+ if modTime.After(now) {
+ modTime = now
+ }
+
+ w.Header().Set("Last-Modified", modTime.UTC().Format(http.TimeFormat))
+}
+
+// currentTime returns time.Now() everytime it's called. It's used for mocking in tests.
+var currentTime = func() time.Time {
+ return time.Now()
+}
diff --git a/middleware/middleware_test.go b/middleware/middleware_test.go
index 700beed84..62fa4e250 100644
--- a/middleware/middleware_test.go
+++ b/middleware/middleware_test.go
@@ -1,8 +1,11 @@
package middleware
import (
+ "fmt"
"net/http"
+ "net/http/httptest"
"testing"
+ "time"
)
func TestIndexfile(t *testing.T) {
@@ -42,3 +45,64 @@ func TestIndexfile(t *testing.T) {
}
}
}
+
+func TestSetLastModified(t *testing.T) {
+ nowTime := time.Now()
+
+ // ovewrite the function to return reliable time
+ originalGetCurrentTimeFunc := currentTime
+ currentTime = func() time.Time {
+ return nowTime
+ }
+ defer func() {
+ currentTime = originalGetCurrentTimeFunc
+ }()
+
+ pastTime := nowTime.Truncate(1 * time.Hour)
+ futureTime := nowTime.Add(1 * time.Hour)
+
+ tests := []struct {
+ inputModTime time.Time
+ expectedIsHeaderSet bool
+ expectedLastModified string
+ }{
+ {
+ inputModTime: pastTime,
+ expectedIsHeaderSet: true,
+ expectedLastModified: pastTime.UTC().Format(http.TimeFormat),
+ },
+ {
+ inputModTime: nowTime,
+ expectedIsHeaderSet: true,
+ expectedLastModified: nowTime.UTC().Format(http.TimeFormat),
+ },
+ {
+ inputModTime: futureTime,
+ expectedIsHeaderSet: true,
+ expectedLastModified: nowTime.UTC().Format(http.TimeFormat),
+ },
+ {
+ inputModTime: time.Time{},
+ expectedIsHeaderSet: false,
+ },
+ }
+
+ for i, test := range tests {
+ responseRecorder := httptest.NewRecorder()
+ errorPrefix := fmt.Sprintf("Test [%d]: ", i)
+ SetLastModifiedHeader(responseRecorder, test.inputModTime)
+ actualLastModifiedHeader := responseRecorder.Header().Get("Last-Modified")
+
+ if test.expectedIsHeaderSet && actualLastModifiedHeader == "" {
+ t.Fatalf(errorPrefix + "Expected to find Last-Modified header, but found nothing")
+ }
+
+ if !test.expectedIsHeaderSet && actualLastModifiedHeader != "" {
+ t.Fatalf(errorPrefix+"Did not expect to find Last-Modified header, but found one [%s].", actualLastModifiedHeader)
+ }
+
+ if test.expectedLastModified != actualLastModifiedHeader {
+ t.Errorf(errorPrefix+"Expected Last-Modified content [%s], found [%s}", test.expectedLastModified, actualLastModifiedHeader)
+ }
+ }
+}
diff --git a/middleware/templates/templates.go b/middleware/templates/templates.go
index a699d0026..bc48ac45d 100644
--- a/middleware/templates/templates.go
+++ b/middleware/templates/templates.go
@@ -33,8 +33,18 @@ func (t Templates) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error
// Create execution context
ctx := middleware.Context{Root: t.FileSys, Req: r, URL: r.URL}
+ // New template
+ templateName := filepath.Base(fpath)
+ tpl := template.New(templateName)
+
+ // Set delims
+ if rule.Delims != [2]string{} {
+ tpl.Delims(rule.Delims[0], rule.Delims[1])
+ }
+
// Build the template
- tpl, err := template.ParseFiles(filepath.Join(t.Root, fpath))
+ templatePath := filepath.Join(t.Root, fpath)
+ tpl, err := tpl.ParseFiles(templatePath)
if err != nil {
if os.IsNotExist(err) {
return http.StatusNotFound, nil
@@ -50,6 +60,12 @@ func (t Templates) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error
if err != nil {
return http.StatusInternalServerError, err
}
+
+ templateInfo, err := os.Stat(templatePath)
+ if err == nil {
+ // add the Last-Modified header if we were able to optain the information
+ middleware.SetLastModifiedHeader(w, templateInfo.ModTime())
+ }
buf.WriteTo(w)
return http.StatusOK, nil
@@ -75,4 +91,5 @@ type Rule struct {
Path string
Extensions []string
IndexFiles []string
+ Delims [2]string
}
diff --git a/middleware/templates/templates_test.go b/middleware/templates/templates_test.go
index 3ee6072ce..c5a5d24a8 100644
--- a/middleware/templates/templates_test.go
+++ b/middleware/templates/templates_test.go
@@ -23,6 +23,7 @@ func Test(t *testing.T) {
Extensions: []string{".html", ".htm"},
IndexFiles: []string{"index.html", "index.htm"},
Path: "/images",
+ Delims: [2]string{"{%", "%}"},
},
},
Root: "./testdata",
@@ -94,6 +95,30 @@ func Test(t *testing.T) {
t.Fatalf("Test: the expected body %v is different from the response one: %v", expectedBody, respBody)
}
+ /*
+ * Test tmpl on /images/img2.htm
+ */
+ req, err = http.NewRequest("GET", "/images/img2.htm", nil)
+ if err != nil {
+ t.Fatalf("Could not create HTTP request: %v", err)
+ }
+
+ rec = httptest.NewRecorder()
+
+ tmpl.ServeHTTP(rec, req)
+
+ if rec.Code != http.StatusOK {
+ t.Fatalf("Test: Wrong response code: %d, should be %d", rec.Code, http.StatusOK)
+ }
+
+ respBody = rec.Body.String()
+ expectedBody = `img{{.Include "header.html"}}
+`
+
+ if respBody != expectedBody {
+ t.Fatalf("Test: the expected body %v is different from the response one: %v", expectedBody, respBody)
+ }
+
/*
* Test tmplroot on /root.html
*/
diff --git a/middleware/templates/testdata/images/img.htm b/middleware/templates/testdata/images/img.htm
index 865a73809..c90602044 100644
--- a/middleware/templates/testdata/images/img.htm
+++ b/middleware/templates/testdata/images/img.htm
@@ -1 +1 @@
-img{{.Include "header.html"}}
+img{%.Include "header.html"%}
diff --git a/middleware/templates/testdata/images/img2.htm b/middleware/templates/testdata/images/img2.htm
new file mode 100644
index 000000000..865a73809
--- /dev/null
+++ b/middleware/templates/testdata/images/img2.htm
@@ -0,0 +1 @@
+img{{.Include "header.html"}}
diff --git a/middleware/websocket/websocket.go b/middleware/websocket/websocket.go
index f344fe511..76b2bfed8 100644
--- a/middleware/websocket/websocket.go
+++ b/middleware/websocket/websocket.go
@@ -172,7 +172,7 @@ func reader(conn *websocket.Conn, stdout io.ReadCloser, stdin io.WriteCloser) {
conn.SetReadDeadline(time.Now().Add(pongWait))
conn.SetPongHandler(func(string) error { conn.SetReadDeadline(time.Now().Add(pongWait)); return nil })
tickerChan := make(chan bool)
- defer func() { tickerChan <- true }() // make sure to close the ticker when we are done.
+ defer close(tickerChan) // make sure to close the ticker when we are done.
go ticker(conn, tickerChan)
for {
@@ -213,10 +213,7 @@ func reader(conn *websocket.Conn, stdout io.ReadCloser, stdin io.WriteCloser) {
// between the server and client to keep it alive with ping messages.
func ticker(conn *websocket.Conn, c chan bool) {
ticker := time.NewTicker(pingPeriod)
- defer func() {
- ticker.Stop()
- close(c)
- }()
+ defer ticker.Stop()
for { // blocking loop with select to wait for stimulation.
select {