mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
187 lines
7.0 KiB
Go
187 lines
7.0 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"slices"
|
|
|
|
"github.com/pkg/errors"
|
|
"google.golang.org/protobuf/encoding/protojson"
|
|
|
|
storepb "github.com/usememos/memos/proto/gen/store"
|
|
)
|
|
|
|
// MaxUsageLimitEntries is the most entries the usage limits setting can hold.
|
|
const MaxUsageLimitEntries = 100
|
|
|
|
// MaxUsageLimitUsers is the most user IDs the usage limits setting can name
|
|
// across all entries. All entries share one system_setting row, so the cap
|
|
// also bounds that row's size.
|
|
const MaxUsageLimitUsers = 1000
|
|
|
|
// DefaultUploadBytes is the built-in per-file upload limit in bytes. 32 MiB.
|
|
const DefaultUploadBytes int64 = 32 << 20
|
|
|
|
// DefaultMemoContentBytes is the built-in per-memo content limit in bytes. 8 KiB.
|
|
const DefaultMemoContentBytes int64 = 8 << 10
|
|
|
|
// usageLimitWriteAttempts bounds the read, modify, and conditional write cycle
|
|
// when other writers keep changing the usage limits row.
|
|
const usageLimitWriteAttempts = 5
|
|
|
|
var (
|
|
// ErrInvalidUsageLimits indicates a usage limits setting that breaks a
|
|
// validation rule.
|
|
ErrInvalidUsageLimits = errors.New("invalid usage limits")
|
|
// ErrUsageLimitWriteConflict indicates that other writers changed the usage
|
|
// limits on every attempt.
|
|
ErrUsageLimitWriteConflict = errors.New("usage limits changed concurrently; retry")
|
|
)
|
|
|
|
// DefaultInstanceUsageLimitsSetting is the setting in effect when none is
|
|
// stored: one entry for every user that limits memo content to 8 KiB and
|
|
// uploads to 32 MiB.
|
|
func DefaultInstanceUsageLimitsSetting() *storepb.InstanceUsageLimitsSetting {
|
|
uploadBytes, contentBytes := DefaultUploadBytes, DefaultMemoContentBytes
|
|
return &storepb.InstanceUsageLimitsSetting{Limits: []*storepb.InstanceUsageLimitsSetting_UsageLimit{{
|
|
AllUsers: true,
|
|
MemoContentBytes: &contentBytes,
|
|
UploadBytes: &uploadBytes,
|
|
}}}
|
|
}
|
|
|
|
// ValidateInstanceUsageLimitsSetting checks the rules every stored usage
|
|
// limits setting meets, whether it comes from the API or from a deployment
|
|
// file: at most MaxUsageLimitEntries entries naming at most MaxUsageLimitUsers
|
|
// users, every entry names positive, unrepeated users or all users but not
|
|
// both, the last entry and only the last entry names all users, and no limit
|
|
// is negative.
|
|
func ValidateInstanceUsageLimitsSetting(setting *storepb.InstanceUsageLimitsSetting) error {
|
|
if setting == nil {
|
|
return errors.Wrap(ErrInvalidUsageLimits, "usage limits must be populated")
|
|
}
|
|
limits := setting.GetLimits()
|
|
if len(limits) == 0 {
|
|
return errors.Wrap(ErrInvalidUsageLimits, "the last entry must apply to all users")
|
|
}
|
|
if len(limits) > MaxUsageLimitEntries {
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "at most %d entries are allowed", MaxUsageLimitEntries)
|
|
}
|
|
userCount := 0
|
|
for i, limit := range limits {
|
|
if limit == nil {
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "limits[%d] must not be null", i)
|
|
}
|
|
last := i == len(limits)-1
|
|
switch {
|
|
case limit.AllUsers && len(limit.UserIds) > 0:
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "limits[%d] names users and all users; choose one", i)
|
|
case limit.AllUsers && !last:
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "limits[%d] applies to all users, so it must be the last entry", i)
|
|
case !limit.AllUsers && last:
|
|
return errors.Wrap(ErrInvalidUsageLimits, "the last entry must apply to all users")
|
|
case !limit.AllUsers && len(limit.UserIds) == 0:
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "limits[%d] must name at least one user", i)
|
|
}
|
|
// The cap comes before the duplicate scan, so an oversized entry is
|
|
// refused before its quadratic check runs.
|
|
userCount += len(limit.UserIds)
|
|
if userCount > MaxUsageLimitUsers {
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "at most %d users can be named across all entries", MaxUsageLimitUsers)
|
|
}
|
|
for j, userID := range limit.UserIds {
|
|
if userID <= 0 {
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "limits[%d].userIds[%d] must be positive", i, j)
|
|
}
|
|
if slices.Contains(limit.UserIds[:j], userID) {
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "limits[%d] names user %d more than once", i, userID)
|
|
}
|
|
}
|
|
for _, value := range []struct {
|
|
name string
|
|
value *int64
|
|
}{
|
|
{"memoCount", limit.MemoCount},
|
|
{"memoContentBytes", limit.MemoContentBytes},
|
|
{"storageBytes", limit.StorageBytes},
|
|
{"uploadBytes", limit.UploadBytes},
|
|
} {
|
|
if value.value != nil && *value.value < 0 {
|
|
return errors.Wrapf(ErrInvalidUsageLimits, "limits[%d].%s must not be negative", i, value.name)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetInstanceUsageLimitsSetting returns the usage limits setting. The database
|
|
// row is read directly, without the instance setting cache, so a change made
|
|
// through any replica applies at the next check on every replica. An absent
|
|
// setting is DefaultInstanceUsageLimitsSetting.
|
|
func (s *Store) GetInstanceUsageLimitsSetting(ctx context.Context) (*storepb.InstanceUsageLimitsSetting, error) {
|
|
instanceSetting, err := s.GetUncachedInstanceSetting(ctx, &FindInstanceSetting{Name: storepb.InstanceSettingKey_USAGE_LIMITS.String()})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to get usage limits setting")
|
|
}
|
|
if setting := instanceSetting.GetUsageLimitsSetting(); setting != nil {
|
|
if err := ValidateInstanceUsageLimitsSetting(setting); err != nil {
|
|
return nil, errors.Wrap(err, "invalid usage limits setting")
|
|
}
|
|
return setting, nil
|
|
}
|
|
return DefaultInstanceUsageLimitsSetting(), nil
|
|
}
|
|
|
|
// RemoveUserFromUsageLimits drops userID from every entry of the stored usage
|
|
// limits, and drops entries left without users.
|
|
func (s *Store) RemoveUserFromUsageLimits(ctx context.Context, userID int32) error {
|
|
if userID == 0 {
|
|
return nil
|
|
}
|
|
name := storepb.InstanceSettingKey_USAGE_LIMITS.String()
|
|
for range usageLimitWriteAttempts {
|
|
list, err := s.driver.ListInstanceSettings(ctx, &FindInstanceSetting{Name: name})
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to read usage limits")
|
|
}
|
|
if len(list) == 0 {
|
|
return nil
|
|
}
|
|
oldValue := list[0].Value
|
|
current := &storepb.InstanceUsageLimitsSetting{}
|
|
if err := protojsonUnmarshaler.Unmarshal([]byte(oldValue), current); err != nil {
|
|
return errors.Wrap(err, "failed to parse stored usage limits")
|
|
}
|
|
changed := false
|
|
next := make([]*storepb.InstanceUsageLimitsSetting_UsageLimit, 0, len(current.Limits))
|
|
for _, limit := range current.Limits {
|
|
if limit == nil {
|
|
continue
|
|
}
|
|
if slices.Contains(limit.UserIds, userID) {
|
|
changed = true
|
|
limit.UserIds = slices.DeleteFunc(limit.UserIds, func(id int32) bool { return id == userID })
|
|
if !limit.AllUsers && len(limit.UserIds) == 0 {
|
|
continue
|
|
}
|
|
}
|
|
next = append(next, limit)
|
|
}
|
|
if !changed {
|
|
return nil
|
|
}
|
|
valueBytes, err := protojson.Marshal(&storepb.InstanceUsageLimitsSetting{Limits: next})
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to marshal usage limits")
|
|
}
|
|
written, err := s.driver.UpdateInstanceSettingIfUnchanged(ctx, name, oldValue, string(valueBytes))
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to write usage limits")
|
|
}
|
|
if written {
|
|
s.instanceSettingCache.Delete(ctx, name)
|
|
return nil
|
|
}
|
|
}
|
|
return ErrUsageLimitWriteConflict
|
|
}
|