From 4bc1cd5f7bcadf16d6108612ea06b132833abdcb Mon Sep 17 00:00:00 2001 From: Moritz Marquardt Date: Thu, 8 Jul 2021 23:08:30 +0200 Subject: [PATCH] Add file cache --- handler.go | 69 ++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 56 insertions(+), 13 deletions(-) diff --git a/handler.go b/handler.go index 8cb5754..7deae03 100644 --- a/handler.go +++ b/handler.go @@ -6,6 +6,7 @@ import ( "github.com/OrlovEvgeny/go-mcache" "github.com/valyala/fasthttp" "github.com/valyala/fastjson" + "io" "mime" "path" "strconv" @@ -212,11 +213,25 @@ func returnErrorPage(ctx *fasthttp.RequestCtx, code int) { ctx.Response.SetBody(bytes.ReplaceAll(NotFoundPage, []byte("%status"), []byte(strconv.Itoa(code)+" "+fasthttp.StatusMessage(code)))) } +// BranchCacheTimeout specifies the timeout for the branch timestamp cache. +var BranchCacheTimeout = 60*time.Second +// branchTimestampCache stores branch timestamps for faster cache checking +var branchTimestampCache = mcache.New() type branchTimestamp struct { branch string timestamp time.Time } -var branchTimestampCache = mcache.New() + +// FileCacheTimeout specifies the timeout for the file content cache - you might want to make this shorter +// than BranchCacheTimeout when running out of memory. +var FileCacheTimeout = 60*time.Second +// fileResponseCache stores responses from the Gitea server +var fileResponseCache = mcache.New() +type fileResponse struct { + exists bool + mimeType string + body []byte +} // getBranchTimestamp finds the default branch (if branch is "") and returns the last modification time of the branch // (or an empty time.Time if the branch doesn't exist) @@ -228,16 +243,15 @@ func getBranchTimestamp(owner, repo, branch string) *branchTimestamp { result.branch = branch if branch == "" { var body = make([]byte, 0) - status, body, err := fasthttp.GetTimeout(body, string(GiteaRoot)+"/api/v1/repos/"+owner+"/"+repo, 10*time.Second) + status, body, err := fasthttp.GetTimeout(body, string(GiteaRoot)+"/api/v1/repos/"+owner+"/"+repo, BranchCacheTimeout) if err != nil || status != 200 { return nil } - branch = fastjson.GetString(body, "default_branch") - result.branch = branch + result.branch = fastjson.GetString(body, "default_branch") } var body = make([]byte, 0) - status, body, err := fasthttp.GetTimeout(body, string(GiteaRoot)+"/api/v1/repos/"+owner+"/"+repo+"/branches/"+branch, 10*time.Second) + status, body, err := fasthttp.GetTimeout(body, string(GiteaRoot)+"/api/v1/repos/"+owner+"/"+repo+"/branches/"+branch, BranchCacheTimeout) if err != nil || status != 200 { return nil } @@ -251,11 +265,11 @@ var upstreamClient = fasthttp.Client{ ReadTimeout: 10 * time.Second, MaxConnDuration: 60 * time.Second, MaxConnWaitTimeout: 1000 * time.Millisecond, - MaxConnsPerHost: 1024 * 16, // TODO: adjust bottlenecks for best performance with Gitea! + MaxConnsPerHost: 128 * 16, // TODO: adjust bottlenecks for best performance with Gitea! } - // upstream requests a file from the Gitea API at GiteaRoot and writes it to the request context. -func upstream(ctx *fasthttp.RequestCtx, targetOwner string, targetRepo string, targetBranch string, targetPath string, options *upstreamOptions) (success bool) { +// upstream requests a file from the Gitea API at GiteaRoot and writes it to the request context. +func upstream(ctx *fasthttp.RequestCtx, targetOwner string, targetRepo string, targetBranch string, targetPath string, options *upstreamOptions) (final bool) { if options.ForbiddenMimeTypes == nil { options.ForbiddenMimeTypes = map[string]struct{}{} } @@ -289,10 +303,18 @@ func upstream(ctx *fasthttp.RequestCtx, targetOwner string, targetRepo string, t req := fasthttp.AcquireRequest() req.SetRequestURI(string(GiteaRoot) + "/api/v1/repos/" + targetOwner + "/" + targetRepo + "/raw/" + targetBranch + "/" + targetPath) res := fasthttp.AcquireResponse() - err := upstreamClient.Do(req, res) + isCached := false + var cachedResponse fileResponse + var err error + if cachedValue, ok := fileResponseCache.Get(string(req.RequestURI())); ok { + isCached = true + cachedResponse = cachedValue.(fileResponse) + } else { + err = upstreamClient.Do(req, res) + } // Handle errors - if res.StatusCode() == fasthttp.StatusNotFound { + if (isCached && !cachedResponse.exists) || res.StatusCode() == fasthttp.StatusNotFound { if options.TryIndexPages { // copy the options struct & try if an index page exists optionsForIndexPages := *options @@ -305,15 +327,22 @@ func upstream(ctx *fasthttp.RequestCtx, targetOwner string, targetRepo string, t } } ctx.Response.SetStatusCode(fasthttp.StatusNotFound) + if !isCached { + // Update cache if the request is fresh + _ = fileResponseCache.Set(string(req.RequestURI()), fileResponse{ + exists: false, + }, FileCacheTimeout) + } return false } - if err != nil || res.StatusCode() != fasthttp.StatusOK { + if !isCached && (err != nil || res.StatusCode() != fasthttp.StatusOK) { fmt.Printf("Couldn't fetch contents from \"%s\": %s (status code %d)\n", req.RequestURI(), err, res.StatusCode()) returnErrorPage(ctx, fasthttp.StatusInternalServerError) return true } // Append trailing slash if missing (for index files) + // options.AppendTrailingSlash is only true when looking for index pages if options.AppendTrailingSlash && !bytes.HasSuffix(ctx.Request.URI().Path(), []byte{'/'}) { ctx.Redirect(string(ctx.Request.URI().Path())+"/", fasthttp.StatusTemporaryRedirect) return true @@ -331,16 +360,30 @@ func upstream(ctx *fasthttp.RequestCtx, targetOwner string, targetRepo string, t } ctx.Response.Header.SetContentType(mimeType) - // Write the response to the original request + // Everything's okay so far ctx.Response.SetStatusCode(fasthttp.StatusOK) ctx.Response.Header.SetLastModified(options.BranchTimestamp) - err = res.BodyWriteTo(ctx.Response.BodyWriter()) + + // Write the response body to the original request + var cacheBodyWriter bytes.Buffer + if !isCached { + err = res.BodyWriteTo(io.MultiWriter(ctx.Response.BodyWriter(), &cacheBodyWriter)) + } else { + _, err = ctx.Write(cachedResponse.body) + } if err != nil { fmt.Printf("Couldn't write body for \"%s\": %s\n", req.RequestURI(), err) returnErrorPage(ctx, fasthttp.StatusInternalServerError) return true } + if !isCached { + cachedResponse.exists = true + cachedResponse.mimeType = mimeType + cachedResponse.body = cacheBodyWriter.Bytes() + _ = fileResponseCache.Set(string(req.RequestURI()), cachedResponse, FileCacheTimeout) + } + return true }