mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-19 02:53:25 +02:00
To avoid duplicated load of the same data in an HTTP request, we can set a context cache to do that. i.e. Some pages may load a user from a database with the same id in different areas on the same page. But the code is hidden in two different deep logic. How should we share the user? As a result of this PR, now if both entry functions accept `context.Context` as the first parameter and we just need to refactor `GetUserByID` to reuse the user from the context cache. Then it will not be loaded twice on an HTTP request. But of course, sometimes we would like to reload an object from the database, that's why `RemoveContextData` is also exposed. The core context cache is here. It defines a new context ```go type cacheContext struct { ctx context.Context data map[any]map[any]any lock sync.RWMutex } var cacheContextKey = struct{}{} func WithCacheContext(ctx context.Context) context.Context { return context.WithValue(ctx, cacheContextKey, &cacheContext{ ctx: ctx, data: make(map[any]map[any]any), }) } ``` Then you can use the below 4 methods to read/write/del the data within the same context. ```go func GetContextData(ctx context.Context, tp, key any) any func SetContextData(ctx context.Context, tp, key, value any) func RemoveContextData(ctx context.Context, tp, key any) func GetWithContextCache[T any](ctx context.Context, cacheGroupKey string, cacheTargetID any, f func() (T, error)) (T, error) ``` Then let's take a look at how `system.GetString` implement it. ```go func GetSetting(ctx context.Context, key string) (string, error) { return cache.GetWithContextCache(ctx, contextCacheKey, key, func() (string, error) { return cache.GetString(genSettingCacheKey(key), func() (string, error) { res, err := GetSettingNoCache(ctx, key) if err != nil { return "", err } return res.SettingValue, nil }) }) } ``` First, it will check if context data include the setting object with the key. If not, it will query from the global cache which may be memory or a Redis cache. If not, it will get the object from the database. In the end, if the object gets from the global cache or database, it will be set into the context cache. An object stored in the context cache will only be destroyed after the context disappeared.
197 lines
6.5 KiB
Go
197 lines
6.5 KiB
Go
// Copyright 2021 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package avatars
|
|
|
|
import (
|
|
"context"
|
|
"net/url"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
|
|
"code.gitea.io/gitea/models/db"
|
|
system_model "code.gitea.io/gitea/models/system"
|
|
"code.gitea.io/gitea/modules/base"
|
|
"code.gitea.io/gitea/modules/cache"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
)
|
|
|
|
const (
|
|
// DefaultAvatarClass is the default class of a rendered avatar
|
|
DefaultAvatarClass = "ui avatar gt-vm"
|
|
// DefaultAvatarPixelSize is the default size in pixels of a rendered avatar
|
|
DefaultAvatarPixelSize = 28
|
|
)
|
|
|
|
// EmailHash represents a pre-generated hash map (mainly used by LibravatarURL, it queries email server's DNS records)
|
|
type EmailHash struct {
|
|
Hash string `xorm:"pk varchar(32)"`
|
|
Email string `xorm:"UNIQUE NOT NULL"`
|
|
}
|
|
|
|
func init() {
|
|
db.RegisterModel(new(EmailHash))
|
|
}
|
|
|
|
var (
|
|
defaultAvatarLink string
|
|
once sync.Once
|
|
)
|
|
|
|
// DefaultAvatarLink the default avatar link
|
|
func DefaultAvatarLink() string {
|
|
once.Do(func() {
|
|
u, err := url.Parse(setting.AppSubURL)
|
|
if err != nil {
|
|
log.Error("Can not parse AppSubURL: %v", err)
|
|
return
|
|
}
|
|
|
|
u.Path = path.Join(u.Path, "/assets/img/avatar_default.png")
|
|
defaultAvatarLink = u.String()
|
|
})
|
|
return defaultAvatarLink
|
|
}
|
|
|
|
// HashEmail hashes email address to MD5 string. https://en.gravatar.com/site/implement/hash/
|
|
func HashEmail(email string) string {
|
|
return base.EncodeMD5(strings.ToLower(strings.TrimSpace(email)))
|
|
}
|
|
|
|
// GetEmailForHash converts a provided md5sum to the email
|
|
func GetEmailForHash(md5Sum string) (string, error) {
|
|
return cache.GetString("Avatar:"+md5Sum, func() (string, error) {
|
|
emailHash := EmailHash{
|
|
Hash: strings.ToLower(strings.TrimSpace(md5Sum)),
|
|
}
|
|
|
|
_, err := db.GetEngine(db.DefaultContext).Get(&emailHash)
|
|
return emailHash.Email, err
|
|
})
|
|
}
|
|
|
|
// LibravatarURL returns the URL for the given email. Slow due to the DNS lookup.
|
|
// This function should only be called if a federated avatar service is enabled.
|
|
func LibravatarURL(email string) (*url.URL, error) {
|
|
urlStr, err := system_model.LibravatarService.FromEmail(email)
|
|
if err != nil {
|
|
log.Error("LibravatarService.FromEmail(email=%s): error %v", email, err)
|
|
return nil, err
|
|
}
|
|
u, err := url.Parse(urlStr)
|
|
if err != nil {
|
|
log.Error("Failed to parse libravatar url(%s): error %v", urlStr, err)
|
|
return nil, err
|
|
}
|
|
return u, nil
|
|
}
|
|
|
|
// saveEmailHash returns an avatar link for a provided email,
|
|
// the email and hash are saved into database, which will be used by GetEmailForHash later
|
|
func saveEmailHash(email string) string {
|
|
lowerEmail := strings.ToLower(strings.TrimSpace(email))
|
|
emailHash := HashEmail(lowerEmail)
|
|
_, _ = cache.GetString("Avatar:"+emailHash, func() (string, error) {
|
|
emailHash := &EmailHash{
|
|
Email: lowerEmail,
|
|
Hash: emailHash,
|
|
}
|
|
// OK we're going to open a session just because I think that that might hide away any problems with postgres reporting errors
|
|
if err := db.WithTx(db.DefaultContext, func(ctx context.Context) error {
|
|
has, err := db.GetEngine(ctx).Where("email = ? AND hash = ?", emailHash.Email, emailHash.Hash).Get(new(EmailHash))
|
|
if has || err != nil {
|
|
// Seriously we don't care about any DB problems just return the lowerEmail - we expect the transaction to fail most of the time
|
|
return nil
|
|
}
|
|
_, _ = db.GetEngine(ctx).Insert(emailHash)
|
|
return nil
|
|
}); err != nil {
|
|
// Seriously we don't care about any DB problems just return the lowerEmail - we expect the transaction to fail most of the time
|
|
return lowerEmail, nil
|
|
}
|
|
return lowerEmail, nil
|
|
})
|
|
return emailHash
|
|
}
|
|
|
|
// GenerateUserAvatarFastLink returns a fast link (302) to the user's avatar: "/user/avatar/${User.Name}/${size}"
|
|
func GenerateUserAvatarFastLink(userName string, size int) string {
|
|
if size < 0 {
|
|
size = 0
|
|
}
|
|
return setting.AppSubURL + "/user/avatar/" + url.PathEscape(userName) + "/" + strconv.Itoa(size)
|
|
}
|
|
|
|
// GenerateUserAvatarImageLink returns a link for `User.Avatar` image file: "/avatars/${User.Avatar}"
|
|
func GenerateUserAvatarImageLink(userAvatar string, size int) string {
|
|
if size > 0 {
|
|
return setting.AppSubURL + "/avatars/" + url.PathEscape(userAvatar) + "?size=" + strconv.Itoa(size)
|
|
}
|
|
return setting.AppSubURL + "/avatars/" + url.PathEscape(userAvatar)
|
|
}
|
|
|
|
// generateRecognizedAvatarURL generate a recognized avatar (Gravatar/Libravatar) URL, it modifies the URL so the parameter is passed by a copy
|
|
func generateRecognizedAvatarURL(u url.URL, size int) string {
|
|
urlQuery := u.Query()
|
|
urlQuery.Set("d", "identicon")
|
|
if size > 0 {
|
|
urlQuery.Set("s", strconv.Itoa(size))
|
|
}
|
|
u.RawQuery = urlQuery.Encode()
|
|
return u.String()
|
|
}
|
|
|
|
// generateEmailAvatarLink returns a email avatar link.
|
|
// if final is true, it may use a slow path (eg: query DNS).
|
|
// if final is false, it always uses a fast path.
|
|
func generateEmailAvatarLink(ctx context.Context, email string, size int, final bool) string {
|
|
email = strings.TrimSpace(email)
|
|
if email == "" {
|
|
return DefaultAvatarLink()
|
|
}
|
|
|
|
enableFederatedAvatar := system_model.GetSettingBool(ctx, system_model.KeyPictureEnableFederatedAvatar)
|
|
|
|
var err error
|
|
if enableFederatedAvatar && system_model.LibravatarService != nil {
|
|
emailHash := saveEmailHash(email)
|
|
if final {
|
|
// for final link, we can spend more time on slow external query
|
|
var avatarURL *url.URL
|
|
if avatarURL, err = LibravatarURL(email); err != nil {
|
|
return DefaultAvatarLink()
|
|
}
|
|
return generateRecognizedAvatarURL(*avatarURL, size)
|
|
}
|
|
// for non-final link, we should return fast (use a 302 redirection link)
|
|
urlStr := setting.AppSubURL + "/avatar/" + url.PathEscape(emailHash)
|
|
if size > 0 {
|
|
urlStr += "?size=" + strconv.Itoa(size)
|
|
}
|
|
return urlStr
|
|
}
|
|
|
|
disableGravatar := system_model.GetSettingBool(ctx, system_model.KeyPictureDisableGravatar)
|
|
if !disableGravatar {
|
|
// copy GravatarSourceURL, because we will modify its Path.
|
|
avatarURLCopy := *system_model.GravatarSourceURL
|
|
avatarURLCopy.Path = path.Join(avatarURLCopy.Path, HashEmail(email))
|
|
return generateRecognizedAvatarURL(avatarURLCopy, size)
|
|
}
|
|
|
|
return DefaultAvatarLink()
|
|
}
|
|
|
|
// GenerateEmailAvatarFastLink returns a avatar link (fast, the link may be a delegated one: "/avatar/${hash}")
|
|
func GenerateEmailAvatarFastLink(ctx context.Context, email string, size int) string {
|
|
return generateEmailAvatarLink(ctx, email, size, false)
|
|
}
|
|
|
|
// GenerateEmailAvatarFinalLink returns a avatar final link (maybe slow)
|
|
func GenerateEmailAvatarFinalLink(ctx context.Context, email string, size int) string {
|
|
return generateEmailAvatarLink(ctx, email, size, true)
|
|
}
|