more caching in-client

server/gitea/cache.go

@@ -1,5 +1,7 @@
 package gitea
 
+import "time"
+
 type FileResponse struct {
 	Exists   bool
 	ETag     []byte
@@ -10,3 +12,18 @@ type FileResponse struct {
 func (f FileResponse) IsEmpty() bool {
 	return len(f.Body) != 0
 }
+
+type BranchTimestamp struct {
+	Branch    string
+	Timestamp time.Time
+}
+
+var (
+	// defaultBranchCacheTimeout specifies the timeout for the default branch cache. It can be quite long.
+	defaultBranchCacheTimeout = 15 * time.Minute
+
+	// branchExistenceCacheTimeout specifies the timeout for the branch timestamp & existence cache. It should be shorter
+	// than fileCacheTimeout, as that gets invalidated if the branch timestamp has changed. That way, repo changes will be
+	// picked up faster, while still allowing the content to be cached longer if nothing changes.
+	branchExistenceCacheTimeout = 5 * time.Minute
+)

server/gitea/client.go

@@ -5,3 +5,8 @@ import (
 )
 
 var ErrorNotFound = errors.New("not found")
+
+const (
+	branchTimestampCacheKeyPrefix = "branchTime"
+	defaultBranchCacheKeyPrefix   = "defaultBranch"
+)

server/gitea/client_fasthttp.go

@@ -21,28 +21,28 @@ const (
 )
 
 type Client struct {
-	giteaRoot         string
-	giteaAPIToken     string
-	infoTimeout       time.Duration
-	contentTimeout    time.Duration
-	fastClient        *fasthttp.Client
-	fileResponseCache cache.SetGetKey
+	giteaRoot      string
+	giteaAPIToken  string
+	infoTimeout    time.Duration
+	contentTimeout time.Duration
+	fastClient     *fasthttp.Client
+	responseCache  cache.SetGetKey
 
 	followSymlinks bool
 	supportLFS     bool
 }
 
-func NewClient(giteaRoot, giteaAPIToken string, fileResponseCache cache.SetGetKey, followSymlinks, supportLFS bool) (*Client, error) {
+func NewClient(giteaRoot, giteaAPIToken string, respCache cache.SetGetKey, followSymlinks, supportLFS bool) (*Client, error) {
 	rootURL, err := url.Parse(giteaRoot)
 	giteaRoot = strings.Trim(rootURL.String(), "/")
 
 	return &Client{
-		giteaRoot:         giteaRoot,
-		giteaAPIToken:     giteaAPIToken,
-		infoTimeout:       5 * time.Second,
-		contentTimeout:    10 * time.Second,
-		fastClient:        getFastHTTPClient(),
-		fileResponseCache: fileResponseCache,
+		giteaRoot:      giteaRoot,
+		giteaAPIToken:  giteaAPIToken,
+		infoTimeout:    5 * time.Second,
+		contentTimeout: 10 * time.Second,
+		fastClient:     getFastHTTPClient(),
+		responseCache:  respCache,
 
 		followSymlinks: followSymlinks,
 		supportLFS:     supportLFS,

server/gitea/client_std.go

@@ -16,14 +16,14 @@ import (
 )
 
 type Client struct {
-	sdkClient         *gitea.Client
-	fileResponseCache cache.SetGetKey
+	sdkClient     *gitea.Client
+	responseCache cache.SetGetKey
 
 	followSymlinks bool
 	supportLFS     bool
 }
 
-func NewClient(giteaRoot, giteaAPIToken string, fileResponseCache cache.SetGetKey, followSymlinks, supportLFS bool) (*Client, error) {
+func NewClient(giteaRoot, giteaAPIToken string, respCache cache.SetGetKey, followSymlinks, supportLFS bool) (*Client, error) {
 	rootURL, err := url.Parse(giteaRoot)
 	giteaRoot = strings.Trim(rootURL.String(), "/")
 
@@ -31,8 +31,8 @@ func NewClient(giteaRoot, giteaAPIToken string, fileResponseCache cache.SetGetKe
 
 	sdk, err := gitea.NewClient(giteaRoot, gitea.SetHTTPClient(&stdClient), gitea.SetToken(giteaAPIToken))
 	return &Client{
-		sdkClient:         sdk,
-		fileResponseCache: fileResponseCache,
+		sdkClient:     sdk,
+		responseCache: respCache,
 	}, err
 }
 
@@ -68,18 +68,40 @@ func (client *Client) ServeRawContent(targetOwner, targetRepo, ref, resource str
 	}
 }
 
-func (client *Client) GiteaGetRepoBranchTimestamp(repoOwner, repoName, branchName string) (time.Time, error) {
+func (client *Client) GiteaGetRepoBranchTimestamp(repoOwner, repoName, branchName string) (*BranchTimestamp, error) {
+	cacheKey := fmt.Sprintf("%s/%s/%s/%s", branchTimestampCacheKeyPrefix, repoOwner, repoName, branchName)
+
+	if stamp, ok := client.responseCache.Get(cacheKey); ok && stamp != nil {
+		return stamp.(*BranchTimestamp), nil
+	}
+
 	branch, resp, err := client.sdkClient.GetRepoBranch(repoOwner, repoName, branchName)
 	if err != nil {
-		return time.Time{}, err
+		if resp != nil && resp.StatusCode == http.StatusNotFound {
+			return &BranchTimestamp{}, ErrorNotFound
+		}
+		return &BranchTimestamp{}, err
 	}
 	if resp.StatusCode != http.StatusOK {
-		return time.Time{}, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
+		return &BranchTimestamp{}, fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
 	}
-	return branch.Commit.Timestamp, nil
+
+	stamp := &BranchTimestamp{
+		Branch:    branch.Name,
+		Timestamp: branch.Commit.Timestamp,
+	}
+
+	client.responseCache.Set(cacheKey, stamp, branchExistenceCacheTimeout)
+	return stamp, nil
 }
 
 func (client *Client) GiteaGetRepoDefaultBranch(repoOwner, repoName string) (string, error) {
+	cacheKey := fmt.Sprintf("%s/%s/%s", defaultBranchCacheKeyPrefix, repoOwner, repoName)
+
+	if branch, ok := client.responseCache.Get(cacheKey); ok && branch != nil {
+		return branch.(string), nil
+	}
+
 	repo, resp, err := client.sdkClient.GetRepo(repoOwner, repoName)
 	if err != nil {
 		return "", err
@@ -87,5 +109,8 @@ func (client *Client) GiteaGetRepoDefaultBranch(repoOwner, repoName string) (str
 	if resp.StatusCode != http.StatusOK {
 		return "", fmt.Errorf("unexpected status code '%d'", resp.StatusCode)
 	}
-	return repo.DefaultBranch, nil
+
+	branch := repo.DefaultBranch
+	client.responseCache.Set(cacheKey, branch, defaultBranchCacheTimeout)
+	return branch, nil
 }