fasthttp-rendering-jet-template

//globals
import(
        "github.com/CloudyKit/jet"
        "github.com/patrickmn/go-cache"
        "github.com/tdewolff/minify"
        ......
)

var myCache = cache.New(30 * time.Minute, time.Minute)
var myCompress = NewCompress()
var myConfig Config
var views = jet.NewHTMLSet("./views")

//fasthttp handler
func home(ctx *fasthttp.RequestCtx) {
  locale:=GetUserLocale(ctx)
  ck := fmt.Sprintf("%s_home", locale)   //ck: cache key
	if RenderCache(ctx, ck) {
		return
	}
	p := Page{
		Locale:   locale,
		Title:    LS(locale, "Home"),  //LS: func to get translated string
	}
	......
	m := jet.VarMap{}
	m.Set("LS", LS)	  //use LS in jet template
	m.Set("news", GetPostList(co, "news", 10))
	m.Set("products", GetPostList(co, "products", 10))
	......
	Render(ctx, "public/home", ck, m, p)
}

func Render(ctx *fasthttp.RequestCtx, t, ck string, m jet.VarMap, d interface{}) {
	vw, err := views.GetTemplate(t)
	if err != nil {
		RenderError(ctx, "Template error:" + err.Error())
		return
	}
	ctx.SetContentType("text/html")
	cache := Cache{Type: "text/html"}
	buf := bytes.Buffer{}
	err = vw.Execute(&buf, m, d)
	if err != nil {
		RenderError(ctx, "Render error:" + err.Error())
		return
	}
	var body []byte
	if myConfig.Debug {
		body = buf.Bytes()
	} else {
		body = myCompress.MinifyBytes("text/html", buf.Bytes())
	}
	gzip := strings.Contains(string(ctx.Request.Header.Peek("Accept-Encoding")), "gzip")
	gziped := false
	if gzip && len(body) > 512 {
		zbuf := Gzip(body)
		n := len(zbuf)
		if n > 0 && n < len(body) {
			gziped = true
			ctx.Response.Header.Set("Content-Encoding", "gzip")
			ctx.SetBody(zbuf)
			if ck != "" {
				cache.Gzip = true
				cache.Body = make([]byte, n)
				copy(cache.Body, zbuf)
			}
		}
	}
	if !gziped {
		ctx.SetBody(body)
		if ck != "" && len(body) > 0 {
			cache.Body = make([]byte, len(body))
			copy(cache.Body, body)
		}
	}
	if ck != "" && len(cache.Body) > 0 {
		cache.Etag = HashStr(cache.Body)
		ctx.Response.Header.Set("ETag", cache.Etag)
		myCache.Add(ck, cache, 30 * time.Minute)
	}
	VisitLog(ctx, "Render", fasthttp.StatusOK, len(ctx.Response.Body()))
}

func RenderError(ctx *fasthttp.RequestCtx, msg string) {
	log.Println(msg)
	if myConfig.Debug {
		ctx.SetBodyString(msg)
	} else {
		ctx.Error("Server Error", 500)
	}
}

type Cache struct {
	Type string
	Body []byte
	Etag string
	Gzip bool
}

func RenderCache(ctx *fasthttp.RequestCtx, ck string) bool {
	if ck == "" || myConfig.Debug {
		return false
	}
	cd, ok := myCache.Get(ck)
	if !ok {
		return false
	}
	ce := cd.(Cache)
	etag := string(ctx.Request.Header.Peek("If-None-Match"))
	if etag == ce.Etag {
		ctx.NotModified()
		if ce.Type == "text/html" {
			VisitLog(ctx, "Cache", fasthttp.StatusNotModified, 0)
		}
	} else {
		gzip := strings.Contains(string(ctx.Request.Header.Peek("Accept-Encoding")), "gzip")
		if !gzip && ce.Gzip {
			buf, err := Gunzip(ce.Body)
			if err != nil {
				RenderError(ctx, "Gunzip error: " + err.Error())
				return false
			}
			ctx.SetBody(buf)
			ctx.Response.Header.Set("Content-Length", strconv.Itoa(len(buf)))
		} else {
			ctx.SetBody(ce.Body)
			ctx.Response.Header.Set("Content-Length", strconv.Itoa(len(ce.Body)))
			if ce.Gzip {
				ctx.Response.Header.Set("Content-Encoding", "gzip")
			}
		}
		ctx.SetContentType(ce.Type)
		ctx.Response.Header.Set("ETag", ce.Etag)
		if ce.Type == "text/html" {
			VisitLog(ctx, "Cache", fasthttp.StatusOK, len(ce.Body))
		}
	}
	return true
}

//some funcs used in Render func

type Compress struct {
	minifier *minify.M
}

func NewCompress() *Compress {
	m := minify.New()
	m.AddFunc("text/css", css.Minify)
	m.AddFunc("text/html", html.Minify)
	m.AddFunc("text/javascript", js.Minify)
	m.AddFunc("image/svg+xml", svg.Minify)
	m.AddFuncRegexp(regexp.MustCompile("[/+]json$"), json.Minify)
	m.AddFuncRegexp(regexp.MustCompile("[/+]xml$"), xml.Minify)
	return &Compress{
		minifier: m,
	}
}

func (c *Compress) MinifyBytes(ct string, src []byte) []byte {
	dst, err := c.minifier.Bytes(ct, src)
	if err == nil {
		return dst
	}
	return src
}

import "github.com/klauspost/compress/gzip"   //this is faster than the default gzip

func Gzip(data []byte) []byte {
	var buf bytes.Buffer
	w := gzip.NewWriter(&buf)
	defer w.Close()
	w.Write(data)
	w.Flush()
	return buf.Bytes()
}

func Gunzip(data []byte) ([]byte, error) {
	buf := bytes.NewBuffer(data)
	r, err := gzip.NewReader(buf)
	if err != nil {
		return nil, err
	}
	defer r.Close()
	ud, err := ioutil.ReadAll(r)
	if err != nil {
		return nil, err
	}
	return ud, nil
}

import "github.com/OneOfOne/xxhash"   //xxhash is so-called the fastest hash

func Hash(data []byte) uint64 {
	return xxhash.Checksum64(data)
}

func HashStr(data []byte) string {
	return fmt.Sprintf("%x", Hash(data))[2:]
}