* Added ability to format now and last_modified in responses

Author: Gregor Noczinski

README.md

@@ -52,6 +52,8 @@ filter max_buffer_size    <maximum buffer size in bytes>
             * ``request_proto``: Used proto
             * ``request_remoteAddress``: Remote address of the calling client
             * ``response_header_<header name>``: Contains a header value of the response, if provided or empty.
+            * ``now[:<pattern>]``: Current timestamp. If pattern not provided, `RFC` or `RFC3339` [RFC3339](https://tools.ietf.org/html/rfc3339) is used. Other values: [`unix`](https://en.wikipedia.org/wiki/Unix_time), [`timestamp`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Date/now) or free format following [Golang time formatting rules](https://golang.org/pkg/time/#pkg-constants).
+            * ``response_header_last_modified[:<pattern>]``: Same like `now` for last modification time of current resource - see above. If not send by server current time will be used.
         * Replacements in files: If the replacement is prefixed with a ``@`` character it will be tried
            to find a file with this name and load the replacement from there. This will help you to also
            add replacements with larger payloads which will be ugly direct within the Caddyfile.

ruleReplaceAction.go

@@ -5,6 +5,9 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"time"
+	"fmt"
+	"log"
 )
 
 var paramReplacementPattern = regexp.MustCompile("\\{[a-zA-Z0-9_\\-.]+}")
@@ -57,6 +60,12 @@ func (instance *ruleReplaceAction) contextValueBy(name string) (string, bool) {
 	if strings.HasPrefix(name, "response_") {
 		return instance.contextResponseValueBy(name[9:])
 	}
+	if name == "now" {
+		return instance.contextNowValueBy("")
+	}
+	if strings.HasPrefix(name, "now:") {
+		return instance.contextNowValueBy(name[4:])
+	}
 	return "", false
 }
 
@@ -83,8 +92,48 @@ func (instance *ruleReplaceAction) contextRequestValueBy(name string) (string, b
 }
 
 func (instance *ruleReplaceAction) contextResponseValueBy(name string) (string, bool) {
+	if name == "header_last_modified" || name == "header_last-modified" {
+		return instance.contextLastModifiedValueBy("")
+	}
+	if strings.HasPrefix(name, "header_last_modified:") || strings.HasPrefix(name, "header_last-modified:") {
+		return instance.contextLastModifiedValueBy(name[21:])
+	}
 	if strings.HasPrefix(name, "header_") {
 		return (*instance.responseHeader).Get(name[7:]), true
 	}
 	return "", false
 }
+
+func (instance *ruleReplaceAction) contextNowValueBy(pattern string) (string, bool) {
+	return instance.formatTimeBy(time.Now(), pattern), true
+}
+
+func (instance *ruleReplaceAction) contextLastModifiedValueBy(pattern string) (string, bool) {
+	plain := instance.responseHeader.Get("last-Modified")
+	if plain == "" {
+		// Fallback to now
+		return instance.contextNowValueBy(pattern)
+	}
+	t, err := time.Parse(time.RFC1123, plain)
+	if err != nil {
+		log.Printf("[WARN] Serving illegal 'Last-Modified' header value '%v' for '%v': Got: %v", plain, instance.request.URL, err)
+		// Fallback to now
+		return instance.contextNowValueBy(pattern)
+	}
+	return instance.formatTimeBy(t, pattern), true
+}
+
+func (instance *ruleReplaceAction) formatTimeBy(t time.Time, pattern string) string {
+	if pattern == "" || pattern == "RFC" || pattern == "RFC3339" {
+		return t.Format(time.RFC3339)
+	}
+	if pattern == "unix" {
+		return fmt.Sprintf("%d", t.Unix())
+	}
+	if pattern == "timestamp" {
+		stamp := t.Unix() * 1000
+		stamp += int64(t.Nanosecond()) / int64(1000000)
+		return fmt.Sprintf("%d", stamp)
+	}
+	return t.Format(pattern)
+}

ruleReplaceAction_test.go

@@ -5,6 +5,8 @@ import (
 	"net/http"
 	"net/url"
 	"regexp"
+	"time"
+	"fmt"
 )
 
 var (
@@ -44,8 +46,11 @@ func (s *ruleReplaceActionTest) Test_paramReplacer(c *C) {
 	rra := &ruleReplaceAction{
 		responseHeader: &http.Header{
 			"A": []string{"c"},
+			"Last-Modified": []string{"Tue, 01 Aug 2017 15:13:59 GMT"},
 		},
 	}
+	yearString := time.Now().Format("2006-")
+
 	c.Assert(rra.paramReplacer([]byte("{0}"), groups), DeepEquals, []byte("a"))
 	c.Assert(rra.paramReplacer([]byte("{1}"), groups), DeepEquals, []byte("b"))
 	c.Assert(rra.paramReplacer([]byte("{response_header_A}"), groups), DeepEquals, []byte("c"))
@@ -55,12 +60,17 @@ func (s *ruleReplaceActionTest) Test_paramReplacer(c *C) {
 	c.Assert(rra.paramReplacer([]byte("{2}"), groups), DeepEquals, []byte("{2}"))
 	c.Assert(rra.paramReplacer([]byte("{response_headers_A}"), groups), DeepEquals, []byte("{response_headers_A}"))
 	c.Assert(rra.paramReplacer([]byte("{foo}"), groups), DeepEquals, []byte("{foo}"))
+	c.Assert(rra.paramReplacer([]byte("{now:2006-}"), groups), DeepEquals, []byte(yearString))
+	c.Assert(string(rra.paramReplacer([]byte("{response_header_last_modified}"), groups)), DeepEquals, "2017-08-01T15:13:59Z")
+	c.Assert(string(rra.paramReplacer([]byte("{response_header_last_modified:RFC}"), groups)), DeepEquals, "2017-08-01T15:13:59Z")
+	c.Assert(string(rra.paramReplacer([]byte("{response_header_last_modified:timestamp}"), groups)), DeepEquals, "1501600439000")
 }
 
 func (s *ruleReplaceActionTest) Test_contextValueBy(c *C) {
 	rra := &ruleReplaceAction{
 		responseHeader: &http.Header{
 			"A": []string{"fromResponse"},
+			"Last-Modified": []string{"Tue, 01 Aug 2017 15:13:59 GMT"},
 		},
 		request: &http.Request{
 			Header: http.Header{
@@ -69,6 +79,8 @@ func (s *ruleReplaceActionTest) Test_contextValueBy(c *C) {
 		},
 	}
 
+	yearString := time.Now().Format("2006-")
+
 	r, ok := rra.contextValueBy("request_header_A")
 	c.Assert(ok, Equals, true)
 	c.Assert(r, Equals, "fromRequest")
@@ -77,6 +89,32 @@ func (s *ruleReplaceActionTest) Test_contextValueBy(c *C) {
 	c.Assert(ok, Equals, true)
 	c.Assert(r, Equals, "fromResponse")
 
+	r, ok = rra.contextValueBy("now")
+	c.Assert(ok, Equals, true)
+	c.Assert(len(r), Equals, 25)
+	c.Assert(r[:5], Equals, yearString)
+
+	r, ok = rra.contextValueBy("now:")
+	c.Assert(ok, Equals, true)
+	c.Assert(len(r), Equals, 25)
+	c.Assert(r[:5], Equals, yearString)
+
+	r, ok = rra.contextValueBy("now:xxx2006-xxx")
+	c.Assert(ok, Equals, true)
+	c.Assert(r, Equals, fmt.Sprintf("xxx%sxxx", yearString))
+
+	r, ok = rra.contextValueBy("response_header_last_modified")
+	c.Assert(ok, Equals, true)
+	c.Assert(r, Equals, "2017-08-01T15:13:59Z")
+
+	r, ok = rra.contextValueBy("response_header_last_modified:RFC")
+	c.Assert(ok, Equals, true)
+	c.Assert(r, Equals, "2017-08-01T15:13:59Z")
+
+	r, ok = rra.contextValueBy("response_header_last_modified:timestamp")
+	c.Assert(ok, Equals, true)
+	c.Assert(r, Equals, "1501600439000")
+
 	r, ok = rra.contextValueBy("foo")
 	c.Assert(ok, Equals, false)
 	c.Assert(r, Equals, "")
@@ -168,3 +206,17 @@ func (s *ruleReplaceActionTest) Test_contextResponseValueBy(c *C) {
 	c.Assert(ok, Equals, false)
 	c.Assert(r, Equals, "")
 }
+
+func (s *ruleReplaceActionTest) Test_formatTimeBy(c *C) {
+	rra := &ruleReplaceAction{}
+	now, err := time.Parse(time.RFC3339Nano, "2017-08-15T14:00:00.123456789+02:00")
+	c.Assert(err, IsNil)
+
+	c.Assert(rra.formatTimeBy(now, ""), Equals, "2017-08-15T14:00:00+02:00")
+	c.Assert(rra.formatTimeBy(now, "RFC"), Equals, "2017-08-15T14:00:00+02:00")
+	c.Assert(rra.formatTimeBy(now, "RFC3339"), Equals, "2017-08-15T14:00:00+02:00")
+	c.Assert(rra.formatTimeBy(now, "unix"), Equals, "1502798400")
+	c.Assert(rra.formatTimeBy(now, "timestamp"), Equals, "1502798400123")
+	c.Assert(rra.formatTimeBy(now, "2006-01-02"), Equals, "2017-08-15")
+	c.Assert(rra.formatTimeBy(now, "xxx"), Equals, "xxx")
+}