mirror of
https://github.com/go-gitea/gitea.git
synced 2024-09-08 04:19:36 +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.
310 lines
9.2 KiB
Go
310 lines
9.2 KiB
Go
// Copyright 2021 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package system
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"code.gitea.io/gitea/models/db"
|
|
"code.gitea.io/gitea/modules/cache"
|
|
setting_module "code.gitea.io/gitea/modules/setting"
|
|
"code.gitea.io/gitea/modules/timeutil"
|
|
|
|
"strk.kbt.io/projects/go/libravatar"
|
|
"xorm.io/builder"
|
|
)
|
|
|
|
// Setting is a key value store of user settings
|
|
type Setting struct {
|
|
ID int64 `xorm:"pk autoincr"`
|
|
SettingKey string `xorm:"varchar(255) unique"` // ensure key is always lowercase
|
|
SettingValue string `xorm:"text"`
|
|
Version int `xorm:"version"` // prevent to override
|
|
Created timeutil.TimeStamp `xorm:"created"`
|
|
Updated timeutil.TimeStamp `xorm:"updated"`
|
|
}
|
|
|
|
// TableName sets the table name for the settings struct
|
|
func (s *Setting) TableName() string {
|
|
return "system_setting"
|
|
}
|
|
|
|
func (s *Setting) GetValueBool() bool {
|
|
if s == nil {
|
|
return false
|
|
}
|
|
|
|
b, _ := strconv.ParseBool(s.SettingValue)
|
|
return b
|
|
}
|
|
|
|
func init() {
|
|
db.RegisterModel(new(Setting))
|
|
}
|
|
|
|
// ErrSettingIsNotExist represents an error that a setting is not exist with special key
|
|
type ErrSettingIsNotExist struct {
|
|
Key string
|
|
}
|
|
|
|
// Error implements error
|
|
func (err ErrSettingIsNotExist) Error() string {
|
|
return fmt.Sprintf("System setting[%s] is not exist", err.Key)
|
|
}
|
|
|
|
// IsErrSettingIsNotExist return true if err is ErrSettingIsNotExist
|
|
func IsErrSettingIsNotExist(err error) bool {
|
|
_, ok := err.(ErrSettingIsNotExist)
|
|
return ok
|
|
}
|
|
|
|
// ErrDataExpired represents an error that update a record which has been updated by another thread
|
|
type ErrDataExpired struct {
|
|
Key string
|
|
}
|
|
|
|
// Error implements error
|
|
func (err ErrDataExpired) Error() string {
|
|
return fmt.Sprintf("System setting[%s] has been updated by another thread", err.Key)
|
|
}
|
|
|
|
// IsErrDataExpired return true if err is ErrDataExpired
|
|
func IsErrDataExpired(err error) bool {
|
|
_, ok := err.(ErrDataExpired)
|
|
return ok
|
|
}
|
|
|
|
// GetSettingNoCache returns specific setting without using the cache
|
|
func GetSettingNoCache(ctx context.Context, key string) (*Setting, error) {
|
|
v, err := GetSettings(ctx, []string{key})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(v) == 0 {
|
|
return nil, ErrSettingIsNotExist{key}
|
|
}
|
|
return v[strings.ToLower(key)], nil
|
|
}
|
|
|
|
const contextCacheKey = "system_setting"
|
|
|
|
// GetSetting returns the setting value via the key
|
|
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
|
|
})
|
|
})
|
|
}
|
|
|
|
// GetSettingBool return bool value of setting,
|
|
// none existing keys and errors are ignored and result in false
|
|
func GetSettingBool(ctx context.Context, key string) bool {
|
|
s, _ := GetSetting(ctx, key)
|
|
v, _ := strconv.ParseBool(s)
|
|
return v
|
|
}
|
|
|
|
// GetSettings returns specific settings
|
|
func GetSettings(ctx context.Context, keys []string) (map[string]*Setting, error) {
|
|
for i := 0; i < len(keys); i++ {
|
|
keys[i] = strings.ToLower(keys[i])
|
|
}
|
|
settings := make([]*Setting, 0, len(keys))
|
|
if err := db.GetEngine(db.DefaultContext).
|
|
Where(builder.In("setting_key", keys)).
|
|
Find(&settings); err != nil {
|
|
return nil, err
|
|
}
|
|
settingsMap := make(map[string]*Setting)
|
|
for _, s := range settings {
|
|
settingsMap[s.SettingKey] = s
|
|
}
|
|
return settingsMap, nil
|
|
}
|
|
|
|
type AllSettings map[string]*Setting
|
|
|
|
func (settings AllSettings) Get(key string) Setting {
|
|
if v, ok := settings[strings.ToLower(key)]; ok {
|
|
return *v
|
|
}
|
|
return Setting{}
|
|
}
|
|
|
|
func (settings AllSettings) GetBool(key string) bool {
|
|
b, _ := strconv.ParseBool(settings.Get(key).SettingValue)
|
|
return b
|
|
}
|
|
|
|
func (settings AllSettings) GetVersion(key string) int {
|
|
return settings.Get(key).Version
|
|
}
|
|
|
|
// GetAllSettings returns all settings from user
|
|
func GetAllSettings() (AllSettings, error) {
|
|
settings := make([]*Setting, 0, 5)
|
|
if err := db.GetEngine(db.DefaultContext).
|
|
Find(&settings); err != nil {
|
|
return nil, err
|
|
}
|
|
settingsMap := make(map[string]*Setting)
|
|
for _, s := range settings {
|
|
settingsMap[s.SettingKey] = s
|
|
}
|
|
return settingsMap, nil
|
|
}
|
|
|
|
// DeleteSetting deletes a specific setting for a user
|
|
func DeleteSetting(ctx context.Context, setting *Setting) error {
|
|
cache.RemoveContextData(ctx, contextCacheKey, setting.SettingKey)
|
|
cache.Remove(genSettingCacheKey(setting.SettingKey))
|
|
_, err := db.GetEngine(db.DefaultContext).Delete(setting)
|
|
return err
|
|
}
|
|
|
|
func SetSettingNoVersion(ctx context.Context, key, value string) error {
|
|
s, err := GetSettingNoCache(ctx, key)
|
|
if IsErrSettingIsNotExist(err) {
|
|
return SetSetting(ctx, &Setting{
|
|
SettingKey: key,
|
|
SettingValue: value,
|
|
})
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
s.SettingValue = value
|
|
return SetSetting(ctx, s)
|
|
}
|
|
|
|
// SetSetting updates a users' setting for a specific key
|
|
func SetSetting(ctx context.Context, setting *Setting) error {
|
|
if err := upsertSettingValue(strings.ToLower(setting.SettingKey), setting.SettingValue, setting.Version); err != nil {
|
|
return err
|
|
}
|
|
|
|
setting.Version++
|
|
|
|
cc := cache.GetCache()
|
|
if cc != nil {
|
|
if err := cc.Put(genSettingCacheKey(setting.SettingKey), setting.SettingValue, setting_module.CacheService.TTLSeconds()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
cache.SetContextData(ctx, contextCacheKey, setting.SettingKey, setting.SettingValue)
|
|
return nil
|
|
}
|
|
|
|
func upsertSettingValue(key, value string, version int) error {
|
|
return db.WithTx(db.DefaultContext, func(ctx context.Context) error {
|
|
e := db.GetEngine(ctx)
|
|
|
|
// here we use a general method to do a safe upsert for different databases (and most transaction levels)
|
|
// 1. try to UPDATE the record and acquire the transaction write lock
|
|
// if UPDATE returns non-zero rows are changed, OK, the setting is saved correctly
|
|
// if UPDATE returns "0 rows changed", two possibilities: (a) record doesn't exist (b) value is not changed
|
|
// 2. do a SELECT to check if the row exists or not (we already have the transaction lock)
|
|
// 3. if the row doesn't exist, do an INSERT (we are still protected by the transaction lock, so it's safe)
|
|
//
|
|
// to optimize the SELECT in step 2, we can use an extra column like `revision=revision+1`
|
|
// to make sure the UPDATE always returns a non-zero value for existing (unchanged) records.
|
|
|
|
res, err := e.Exec("UPDATE system_setting SET setting_value=?, version = version+1 WHERE setting_key=? AND version=?", value, key, version)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rows, _ := res.RowsAffected()
|
|
if rows > 0 {
|
|
// the existing row is updated, so we can return
|
|
return nil
|
|
}
|
|
|
|
// in case the value isn't changed, update would return 0 rows changed, so we need this check
|
|
has, err := e.Exist(&Setting{SettingKey: key})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if has {
|
|
return ErrDataExpired{Key: key}
|
|
}
|
|
|
|
// if no existing row, insert a new row
|
|
_, err = e.Insert(&Setting{SettingKey: key, SettingValue: value})
|
|
return err
|
|
})
|
|
}
|
|
|
|
var (
|
|
GravatarSourceURL *url.URL
|
|
LibravatarService *libravatar.Libravatar
|
|
)
|
|
|
|
func Init() error {
|
|
var disableGravatar bool
|
|
disableGravatarSetting, err := GetSettingNoCache(db.DefaultContext, KeyPictureDisableGravatar)
|
|
if IsErrSettingIsNotExist(err) {
|
|
disableGravatar = setting_module.GetDefaultDisableGravatar()
|
|
disableGravatarSetting = &Setting{SettingValue: strconv.FormatBool(disableGravatar)}
|
|
} else if err != nil {
|
|
return err
|
|
} else {
|
|
disableGravatar = disableGravatarSetting.GetValueBool()
|
|
}
|
|
|
|
var enableFederatedAvatar bool
|
|
enableFederatedAvatarSetting, err := GetSettingNoCache(db.DefaultContext, KeyPictureEnableFederatedAvatar)
|
|
if IsErrSettingIsNotExist(err) {
|
|
enableFederatedAvatar = setting_module.GetDefaultEnableFederatedAvatar(disableGravatar)
|
|
enableFederatedAvatarSetting = &Setting{SettingValue: strconv.FormatBool(enableFederatedAvatar)}
|
|
} else if err != nil {
|
|
return err
|
|
} else {
|
|
enableFederatedAvatar = disableGravatarSetting.GetValueBool()
|
|
}
|
|
|
|
if setting_module.OfflineMode {
|
|
disableGravatar = true
|
|
enableFederatedAvatar = false
|
|
if !GetSettingBool(db.DefaultContext, KeyPictureDisableGravatar) {
|
|
if err := SetSettingNoVersion(db.DefaultContext, KeyPictureDisableGravatar, "true"); err != nil {
|
|
return fmt.Errorf("Failed to set setting %q: %w", KeyPictureDisableGravatar, err)
|
|
}
|
|
}
|
|
if GetSettingBool(db.DefaultContext, KeyPictureEnableFederatedAvatar) {
|
|
if err := SetSettingNoVersion(db.DefaultContext, KeyPictureEnableFederatedAvatar, "false"); err != nil {
|
|
return fmt.Errorf("Failed to set setting %q: %w", KeyPictureEnableFederatedAvatar, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
if enableFederatedAvatar || !disableGravatar {
|
|
var err error
|
|
GravatarSourceURL, err = url.Parse(setting_module.GravatarSource)
|
|
if err != nil {
|
|
return fmt.Errorf("Failed to parse Gravatar URL(%s): %w", setting_module.GravatarSource, err)
|
|
}
|
|
}
|
|
|
|
if GravatarSourceURL != nil && enableFederatedAvatarSetting.GetValueBool() {
|
|
LibravatarService = libravatar.New()
|
|
if GravatarSourceURL.Scheme == "https" {
|
|
LibravatarService.SetUseHTTPS(true)
|
|
LibravatarService.SetSecureFallbackHost(GravatarSourceURL.Host)
|
|
} else {
|
|
LibravatarService.SetUseHTTPS(false)
|
|
LibravatarService.SetFallbackHost(GravatarSourceURL.Host)
|
|
}
|
|
}
|
|
return nil
|
|
}
|