Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

Add GZIP middleware to reduce response size (#143)

Guilherme Oenningb6c9733921f6
diff --git a/app/middlewares/cache.go b/app/middlewares/cache.go
index 9393959f1..961e1cb9f 100644
--- a/app/middlewares/cache.go
+++ b/app/middlewares/cache.go
@@ -6,7 +6,7 @@ import "github.com/getfider/fider/app/pkg/web"
func OneYearCache() web.MiddlewareFunc {
return func(next web.HandlerFunc) web.HandlerFunc {
return func(c web.Context) error {
- c.Response().Header().Add("Cache-Control", "public, max-age=30672000")
+ c.Response.Header().Add("Cache-Control", "public, max-age=30672000")
return next(c)
}
}
diff --git a/app/middlewares/compress.go b/app/middlewares/compress.go
new file mode 100644
index 000000000..52c076084
--- /dev/null
+++ b/app/middlewares/compress.go
@@ -0,0 +1,72 @@
+package middlewares
+
+import (
+ "bufio"
+ "compress/gzip"
+ "net"
+ "net/http"
+ "strings"
+
+ "github.com/getfider/fider/app/pkg/web"
+)
+
+var (
+ minSize = 1024
+)
+
+type gzipResponseWriter struct {
+ code int
+ response http.ResponseWriter
+ buffer []byte
+}
+
+// Compress returns a middleware which compresses HTTP response using gzip compression
+func Compress() web.MiddlewareFunc {
+ return func(next web.HandlerFunc) web.HandlerFunc {
+ return func(c web.Context) error {
+ res := c.Response
+ res.Header().Add("Vary", "Accept-Encoding")
+ if strings.Contains(c.Request.Header.Get("Accept-Encoding"), "gzip") {
+ gzipResponse := &gzipResponseWriter{response: res}
+ c.Response = gzipResponse
+ defer gzipResponse.Flush()
+ }
+ return next(c)
+ }
+ }
+}
+func (w *gzipResponseWriter) Header() http.Header {
+ return w.response.Header()
+}
+
+func (w *gzipResponseWriter) WriteHeader(code int) {
+ w.code = code
+}
+
+func (w *gzipResponseWriter) Write(b []byte) (int, error) {
+ w.buffer = append(w.buffer, b...)
+ return len(b), nil
+}
+
+func (w *gzipResponseWriter) Flush() {
+ if len(w.buffer) >= minSize {
+ w.Header().Del("Content-Length")
+ w.Header().Set("Content-Encoding", "gzip")
+ w.response.WriteHeader(w.code)
+ gzipWriter := gzip.NewWriter(w.response)
+ gzipWriter.Write(w.buffer)
+ gzipWriter.Flush()
+ gzipWriter.Close()
+ } else {
+ w.response.WriteHeader(w.code)
+ w.response.Write(w.buffer)
+ }
+}
+
+func (w *gzipResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+ return w.response.(http.Hijacker).Hijack()
+}
+
+func (w *gzipResponseWriter) CloseNotify() <-chan bool {
+ return w.response.(http.CloseNotifier).CloseNotify()
+}
diff --git a/app/middlewares/compress_test.go b/app/middlewares/compress_test.go
new file mode 100644
index 000000000..52d7b5061
--- /dev/null
+++ b/app/middlewares/compress_test.go
@@ -0,0 +1,57 @@
+package middlewares_test
+
+import (
+ "compress/gzip"
+ "io/ioutil"
+ "net/http"
+ "testing"
+
+ "github.com/getfider/fider/app/middlewares"
+ "github.com/getfider/fider/app/pkg/mock"
+ "github.com/getfider/fider/app/pkg/web"
+ . "github.com/onsi/gomega"
+)
+
+func TestCompress(t *testing.T) {
+ RegisterTestingT(t)
+
+ data := "Hello World\n"
+ for i := 0; i <= 500; i++ {
+ data += "Hello World\n"
+ }
+
+ server, _ := mock.NewServer()
+ server.Use(middlewares.Compress())
+ handler := func(c web.Context) error {
+ return c.String(http.StatusOK, data)
+ }
+
+ status, response := server.
+ AddHeader("Accept-Encoding", "gzip").
+ Execute(handler)
+
+ reader, _ := gzip.NewReader(response.Body)
+ Expect(ioutil.ReadAll(reader)).To(Equal([]byte(data)))
+ Expect(status).To(Equal(http.StatusOK))
+ Expect(response.Header().Get("Vary")).To(Equal("Accept-Encoding"))
+ Expect(response.Header().Get("Content-Encoding")).To(Equal("gzip"))
+}
+
+func TestCompress_SmallResponse(t *testing.T) {
+ RegisterTestingT(t)
+
+ server, _ := mock.NewServer()
+ server.Use(middlewares.Compress())
+ handler := func(c web.Context) error {
+ return c.String(http.StatusOK, "Hello World")
+ }
+
+ status, response := server.
+ AddHeader("Accept-Encoding", "gzip").
+ Execute(handler)
+
+ Expect(ioutil.ReadAll(response.Body)).To(Equal([]byte("Hello World")))
+ Expect(status).To(Equal(http.StatusOK))
+ Expect(response.Header().Get("Vary")).To(Equal("Accept-Encoding"))
+ Expect(response.Header().Get("Content-Encoding")).To(Equal(""))
+}
diff --git a/app/middlewares/domain.go b/app/middlewares/domain.go
index 68803e0f9..5e744fec6 100644
--- a/app/middlewares/domain.go
+++ b/app/middlewares/domain.go
@@ -43,7 +43,7 @@ func MultiTenant() web.MiddlewareFunc {
return func(next web.HandlerFunc) web.HandlerFunc {
return func(c web.Context) error {
tenants := c.Services().Tenants
- hostname := stripPort(c.Request().Host)
+ hostname := stripPort(c.Request.Host)
// If no tenant is specified, redirect user to getfider.com
// This is only vadid for fider.io hosting
@@ -85,8 +85,8 @@ func HostChecker(baseURL string) web.MiddlewareFunc {
return c.Failure(err)
}
- if c.Request().Host != u.Host {
- c.Logger().Errorf("%s is not valid for this operation. Only %s is allowed.", c.Request().Host, u.Host)
+ if c.Request.Host != u.Host {
+ c.Logger().Errorf("%s is not valid for this operation. Only %s is allowed.", c.Request.Host, u.Host)
return c.NoContent(http.StatusBadRequest)
}
diff --git a/app/middlewares/jwt.go b/app/middlewares/jwt.go
index 29b7ef9e1..cf48af06e 100644
--- a/app/middlewares/jwt.go
+++ b/app/middlewares/jwt.go
@@ -60,7 +60,7 @@ func JwtSetter() web.MiddlewareFunc {
return func(next web.HandlerFunc) web.HandlerFunc {
return func(c web.Context) error {
- query := c.Request().URL.Query()
+ query := c.Request.URL.Query()
token := query.Get("token")
if token != "" {
@@ -68,7 +68,7 @@ func JwtSetter() web.MiddlewareFunc {
query.Del("token")
- url := c.BaseURL() + c.Request().URL.Path
+ url := c.BaseURL() + c.Request.URL.Path
querystring := query.Encode()
if querystring != "" {
url += "?" + querystring
diff --git a/app/middlewares/setup.go b/app/middlewares/setup.go
index d5e200396..7f6e26f96 100644
--- a/app/middlewares/setup.go
+++ b/app/middlewares/setup.go
@@ -26,7 +26,7 @@ func Noop() web.MiddlewareFunc {
func Setup(db *dbx.Database, emailer email.Sender) web.MiddlewareFunc {
return func(next web.HandlerFunc) web.HandlerFunc {
return func(c web.Context) error {
- c.Logger().Debugf("HTTP Request %s %s", c.Request().Method, c.Request().URL.String())
+ c.Logger().Debugf("HTTP Request %s %s", c.Request.Method, c.Request.URL.String())
trx, err := db.Begin()
if err != nil {
diff --git a/app/pkg/mock/server.go b/app/pkg/mock/server.go
index c8ae0a6b1..460245751 100644
--- a/app/pkg/mock/server.go
+++ b/app/pkg/mock/server.go
@@ -65,20 +65,20 @@ func (s *Server) WithParam(name string, value interface{}) *Server {
// AddHeader add key-value to current context headers
func (s *Server) AddHeader(name string, value string) *Server {
- s.context.Request().Header.Add(name, value)
+ s.context.Request.Header.Add(name, value)
return s
}
// AddCookie add key-value to current context cookies
func (s *Server) AddCookie(name string, value string) *Server {
- s.context.Request().AddCookie(&http.Cookie{Name: name, Value: value})
+ s.context.Request.AddCookie(&http.Cookie{Name: name, Value: value})
return s
}
// WithURL set current context Request URL
func (s *Server) WithURL(fullURL string) *Server {
- s.context.Request().URL, _ = url.Parse(fullURL)
- s.context.Request().Host = s.context.Request().URL.Host
+ s.context.Request.URL, _ = url.Parse(fullURL)
+ s.context.Request.Host = s.context.Request.URL.Host
return s
}
@@ -99,10 +99,10 @@ func (s *Server) ExecuteAsJSON(handler web.HandlerFunc) (int, *jsonq.Query) {
// ExecutePost executes given handler as POST and return response
func (s *Server) ExecutePost(handler web.HandlerFunc, body string) (int, *httptest.ResponseRecorder) {
- s.context.Request().Method = "POST"
- s.context.Request().URL.Path = "/"
- s.context.Request().Body = ioutil.NopCloser(strings.NewReader(body))
- s.context.Request().Header.Set("Content-Type", web.JSONContentType)
+ s.context.Request.Method = "POST"
+ s.context.Request.URL.Path = "/"
+ s.context.Request.Body = ioutil.NopCloser(strings.NewReader(body))
+ s.context.Request.Header.Set("Content-Type", web.JSONContentType)
if err := s.middleware(handler)(s.context); err != nil {
s.context.Failure(err)
diff --git a/app/pkg/web/binder.go b/app/pkg/web/binder.go
index 6f03c1adb..339faca6b 100644
--- a/app/pkg/web/binder.go
+++ b/app/pkg/web/binder.go
@@ -24,9 +24,8 @@ func NewDefaultBinder() *DefaultBinder {
//Bind request data to object i
func (b *DefaultBinder) Bind(target interface{}, c *Context) error {
- req := c.Request()
- if req.Method == http.MethodPost {
- if err := json.NewDecoder(req.Body).Decode(target); err != nil {
+ if c.Request.Method == http.MethodPost {
+ if err := json.NewDecoder(c.Request.Body).Decode(target); err != nil {
return err
}
}
diff --git a/app/pkg/web/context.go b/app/pkg/web/context.go
index e5edb1dd7..e82cc1d79 100644
--- a/app/pkg/web/context.go
+++ b/app/pkg/web/context.go
@@ -44,13 +44,14 @@ var (
servicesContextKey = preffixKey + "SERVICES"
)
+//Context shared between http pipeline
type Context struct {
- engine *Engine
- res http.ResponseWriter
- req *http.Request
- logger log.Logger
- params StringMap
- store Map
+ Response http.ResponseWriter
+ Request *http.Request
+ engine *Engine
+ logger log.Logger
+ params StringMap
+ store Map
}
//Tenant returns current tenant
@@ -97,7 +98,7 @@ func (ctx *Context) IsAuthenticated() bool {
//IsAjax returns true if request is AJAX
func (ctx *Context) IsAjax() bool {
- return strings.Contains(ctx.Request().Header.Get("Accept"), "application/json")
+ return strings.Contains(ctx.Request.Header.Get("Accept"), "application/json")
}
//NotFound returns a 404 page
@@ -243,10 +244,10 @@ func (ctx *Context) ActiveTransaction() *dbx.Trx {
//BaseURL returns base URL as string
func (ctx *Context) BaseURL() string {
protocol := "http"
- if ctx.Request().TLS != nil {
+ if ctx.Request.TLS != nil {
protocol = "https"
}
- return protocol + "://" + ctx.req.Host
+ return protocol + "://" + ctx.Request.Host
}
//TenantBaseURL returns base URL for a given tenant
@@ -256,7 +257,7 @@ func (ctx *Context) TenantBaseURL(tenant *models.Tenant) string {
}
protocol := "http"
- if ctx.req.TLS != nil {
+ if ctx.Request.TLS != nil {
protocol = "https"
}
return protocol + "://" + tenant.Subdomain + env.MultiTenantDomain()
@@ -278,7 +279,7 @@ func (ctx *Context) AuthEndpoint() string {
//QueryParam returns querystring parameter for given key
func (ctx *Context) QueryParam(key string) string {
- return ctx.req.URL.Query().Get(key)
+ return ctx.Request.URL.Query().Get(key)
}
//Param returns parameter as string
@@ -319,16 +320,6 @@ func (ctx *Context) AddRenderVar(name string, value interface{}) {
renderVars.(Map)[name] = value
}
-//Request returns current request
-func (ctx *Context) Request() *http.Request {
- return ctx.req
-}
-
-//Response returns current response writer
-func (ctx *Context) Response() http.ResponseWriter {
- return ctx.res
-}
-
// Get retrieves data from the context.
func (ctx *Context) Get(key string) interface{} {
return ctx.store[key]
@@ -362,37 +353,37 @@ func (ctx *Context) JSON(code int, i interface{}) error {
}
// Blob sends a blob response with status code and content type.
-func (ctx *Context) Blob(code int, contentType string, b []byte) (err error) {
- ctx.res.Header().Set("Content-Type", contentType)
- ctx.res.WriteHeader(code)
- _, err = ctx.res.Write(b)
- return
+func (ctx *Context) Blob(code int, contentType string, b []byte) error {
+ ctx.Response.Header().Set("Content-Type", contentType)
+ ctx.Response.WriteHeader(code)
+ _, err := ctx.Response.Write(b)
+ return err
}
// Cookie returns the named cookie provided in the request.
func (ctx *Context) Cookie(name string) (*http.Cookie, error) {
- return ctx.req.Cookie(name)
+ return ctx.Request.Cookie(name)
}
// SetCookie adds a `Set-Cookie` header in HTTP response.
func (ctx *Context) SetCookie(cookie *http.Cookie) {
- http.SetCookie(ctx.res, cookie)
+ http.SetCookie(ctx.Response, cookie)
}
// Cookies returns the HTTP cookies sent with the request.
func (ctx *Context) Cookies() []*http.Cookie {
- return ctx.req.Cookies()
+ return ctx.Request.Cookies()
}
// NoContent sends a response with no body and a status code.
func (ctx *Context) NoContent(code int) error {
- ctx.res.WriteHeader(code)
+ ctx.Response.WriteHeader(code)
return nil
}
// Redirect redirects the request to a provided URL with status code.
func (ctx *Context) Redirect(code int, url string) error {
- ctx.res.Header().Set("Location", url)
- ctx.res.WriteHeader(code)
+ ctx.Response.Header().Set("Location", url)
+ ctx.Response.WriteHeader(code)
return nil
}
diff --git a/app/pkg/web/engine.go b/app/pkg/web/engine.go
index 1cedb7475..dc97449c6 100644
--- a/app/pkg/web/engine.go
+++ b/app/pkg/web/engine.go
@@ -19,20 +19,22 @@ type MiddlewareFunc func(HandlerFunc) HandlerFunc
//Engine is our web engine wrapper
type Engine struct {
- mux *httprouter.Router
- logger log.Logger
- renderer *Renderer
- binder *DefaultBinder
+ mux *httprouter.Router
+ logger log.Logger
+ renderer *Renderer
+ binder *DefaultBinder
+ middlewares []MiddlewareFunc
}
//New creates a new Engine
func New(settings *models.AppSettings) *Engine {
logger := NewLogger()
router := &Engine{
- mux: httprouter.New(),
- logger: logger,
- renderer: NewRenderer(settings, logger),
- binder: NewDefaultBinder(),
+ mux: httprouter.New(),
+ logger: logger,
+ renderer: NewRenderer(settings, logger),
+ binder: NewDefaultBinder(),
+ middlewares: make([]MiddlewareFunc, 0),
}
router.mux.NotFound = func(res http.ResponseWriter, req *http.Request) {
@@ -64,11 +66,11 @@ func (e *Engine) Start(address string) {
//NewContext creates and return a new context
func (e *Engine) NewContext(res http.ResponseWriter, req *http.Request, params StringMap) Context {
return Context{
- engine: e,
- res: res,
- req: req,
- logger: e.logger,
- params: params,
+ Response: res,
+ Request: req,
+ engine: e,
+ logger: e.logger,
+ params: params,
}
}
@@ -81,11 +83,16 @@ func (e *Engine) Logger() log.Logger {
func (e *Engine) Group() *Group {
g := &Group{
engine: e,
- middlewares: make([]MiddlewareFunc, 0),
+ middlewares: e.middlewares,
}
return g
}
+//Use adds a middleware to the root engine
+func (e *Engine) Use(middleware MiddlewareFunc) {
+ e.middlewares = append(e.middlewares, middleware)
+}
+
//Group is our router group wrapper
type Group struct {
engine *Engine
@@ -136,7 +143,6 @@ func (g *Group) handler(handler HandlerFunc) httprouter.Handle {
// Static return files from given folder
func (g *Group) Static(prefix, root string) {
-
fi, err := os.Stat(root)
if err != nil {
panic(fmt.Sprintf("Path '%s' not found", root))
@@ -148,14 +154,14 @@ func (g *Group) Static(prefix, root string) {
path := root + c.Param("filepath")
fi, err := os.Stat(path)
if err == nil && !fi.IsDir() {
- http.ServeFile(c.Response(), c.Request(), path)
+ http.ServeFile(c.Response, c.Request, path)
return nil
}
return c.NotFound()
}
} else {
h = func(c Context) error {
- http.ServeFile(c.Response(), c.Request(), root)
+ http.ServeFile(c.Response, c.Request, root)
return nil
}
}
diff --git a/routes.go b/routes.go
index 981317328..f5538529b 100644
--- a/routes.go
+++ b/routes.go
@@ -36,6 +36,8 @@ func GetMainEngine(settings *models.AppSettings) *web.Engine {
db.Migrate()
emailer := initEmailer()
+ r.Use(middlewares.Compress())
+
assets := r.Group()
{
assets.Use(middlewares.OneYearCache())