From aed4271c8dc60f34a59c548bbc1b8859b0105be0 Mon Sep 17 00:00:00 2001 From: Unknown Date: Fri, 4 Jul 2014 17:26:15 -0400 Subject: [PATCH] Change martini.Static to custom Static function --- cmd/web.go | 4 +- modules/middleware/static.go | 127 +++++++++++++++++++++++++++++++++++ 2 files changed, 129 insertions(+), 2 deletions(-) create mode 100644 modules/middleware/static.go diff --git a/cmd/web.go b/cmd/web.go index 0515bcee3..3ee38f76c 100644 --- a/cmd/web.go +++ b/cmd/web.go @@ -58,8 +58,8 @@ func newMartini() *martini.ClassicMartini { m := martini.New() m.Use(middleware.Logger()) m.Use(martini.Recovery()) - m.Use(martini.Static(path.Join(setting.StaticRootPath, "public"), - martini.StaticOptions{SkipLogging: !setting.DisableRouterLog})) + m.Use(middleware.Static("public", + middleware.StaticOptions{SkipLogging: !setting.DisableRouterLog})) m.MapTo(r, (*martini.Routes)(nil)) m.Action(r.Handle) return &martini.ClassicMartini{m, r} diff --git a/modules/middleware/static.go b/modules/middleware/static.go new file mode 100644 index 000000000..35f03f721 --- /dev/null +++ b/modules/middleware/static.go @@ -0,0 +1,127 @@ +// Copyright 2013 The Martini Authors. All rights reserved. +// Copyright 2014 The Gogs Authors. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package middleware + +import ( + "log" + "net/http" + "path" + "runtime" + "strings" + + "github.com/go-martini/martini" + + "github.com/gogits/gogs/modules/setting" +) + +// StaticOptions is a struct for specifying configuration options for the martini.Static middleware. +type StaticOptions struct { + // Prefix is the optional prefix used to serve the static directory content + Prefix string + // SkipLogging will disable [Static] log messages when a static file is served. + SkipLogging bool + // IndexFile defines which file to serve as index if it exists. + IndexFile string + // Expires defines which user-defined function to use for producing a HTTP Expires Header + // https://developers.google.com/speed/docs/insights/LeverageBrowserCaching + Expires func() string +} + +func prepareStaticOptions(options []StaticOptions) StaticOptions { + var opt StaticOptions + if len(options) > 0 { + opt = options[0] + } + + // Defaults + if len(opt.IndexFile) == 0 { + opt.IndexFile = "index.html" + } + // Normalize the prefix if provided + if opt.Prefix != "" { + // Ensure we have a leading '/' + if opt.Prefix[0] != '/' { + opt.Prefix = "/" + opt.Prefix + } + // Remove any trailing '/' + opt.Prefix = strings.TrimRight(opt.Prefix, "/") + } + return opt +} + +// Static returns a middleware handler that serves static files in the given directory. +func Static(directory string, staticOpt ...StaticOptions) martini.Handler { + if runtime.GOOS == "windows" { + if len(directory) < 2 || directory[1] != ':' { + directory = path.Join(setting.StaticRootPath, directory) + } + } else if !path.IsAbs(directory) { + directory = path.Join(setting.StaticRootPath, directory) + } + + dir := http.Dir(directory) + opt := prepareStaticOptions(staticOpt) + + return func(res http.ResponseWriter, req *http.Request, log *log.Logger) { + if req.Method != "GET" && req.Method != "HEAD" { + return + } + file := req.URL.Path + // if we have a prefix, filter requests by stripping the prefix + if opt.Prefix != "" { + if !strings.HasPrefix(file, opt.Prefix) { + return + } + file = file[len(opt.Prefix):] + if file != "" && file[0] != '/' { + return + } + } + f, err := dir.Open(file) + if err != nil { + // discard the error? + return + } + defer f.Close() + + fi, err := f.Stat() + if err != nil { + return + } + + // try to serve index file + if fi.IsDir() { + // redirect if missing trailing slash + if !strings.HasSuffix(req.URL.Path, "/") { + http.Redirect(res, req, req.URL.Path+"/", http.StatusFound) + return + } + + file = path.Join(file, opt.IndexFile) + f, err = dir.Open(file) + if err != nil { + return + } + defer f.Close() + + fi, err = f.Stat() + if err != nil || fi.IsDir() { + return + } + } + + if !opt.SkipLogging { + log.Println("[Static] Serving " + file) + } + + // Add an Expires header to the static content + if opt.Expires != nil { + res.Header().Set("Expires", opt.Expires()) + } + + http.ServeContent(res, req, file, fi.ModTime(), f) + } +}