mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
9e3a164dff
Move memo content size into usage limits, with 8 KiB content and 32 MiB upload defaults when settings are absent. Represent stored rule targets with all_users or a positive user_id, and use that same schema for deployment configuration. Rename the memo count metric, remove reserved proto declarations, and renumber fields and enums for the unreleased schema. Synchronize enforcement, settings UI, generated clients, and tests.
434 lines
16 KiB
Go
434 lines
16 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/google/cel-go/cel"
|
|
"github.com/google/cel-go/common/ast"
|
|
"github.com/pkg/errors"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/emptypb"
|
|
|
|
"github.com/usememos/memos/core/usagelimit"
|
|
apipb "github.com/usememos/memos/proto/gen/api"
|
|
storepb "github.com/usememos/memos/proto/gen/store"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
// ListUsageLimits lists the usage limits. Admin only.
|
|
func (s *APIService) ListUsageLimits(ctx context.Context, request *apipb.ListUsageLimitsRequest) (*apipb.ListUsageLimitsResponse, error) {
|
|
if _, err := s.requireUsageLimitAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
filter, err := parseUsageLimitFilter(request.Filter)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid filter: %v", err)
|
|
}
|
|
if filter.username != nil && *filter.username != "" {
|
|
user, err := s.Store.GetUser(ctx, &store.FindUser{Username: filter.username})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get user: %v", err)
|
|
}
|
|
if user == nil {
|
|
return &apipb.ListUsageLimitsResponse{}, nil
|
|
}
|
|
filter.userID = &user.ID
|
|
} else if filter.username != nil {
|
|
everyUser := int32(0)
|
|
filter.userID = &everyUser
|
|
}
|
|
|
|
var limit, offset int
|
|
if request.PageToken != "" {
|
|
var pageToken apipb.PageToken
|
|
if err := unmarshalPageToken(request.PageToken, &pageToken); err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid page token: %v", err)
|
|
}
|
|
limit = normalizePageSize(pageToken.Limit)
|
|
offset = max(int(pageToken.Offset), 0)
|
|
} else {
|
|
limit = normalizePageSize(request.PageSize)
|
|
}
|
|
|
|
limits, usernames, err := s.listVisibleUsageLimits(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
limits = slices.DeleteFunc(limits, func(limit *storepb.InstanceUsageLimitsSetting_UsageLimit) bool {
|
|
return (filter.userID != nil && limit.GetUserId() != *filter.userID) || (filter.metric != nil && limit.Metric != *filter.metric)
|
|
})
|
|
// Defaults first, then by user and metric, so pages are stable.
|
|
slices.SortStableFunc(limits, func(a, b *storepb.InstanceUsageLimitsSetting_UsageLimit) int {
|
|
if a.GetUserId() != b.GetUserId() {
|
|
if a.GetUserId() == 0 || b.GetUserId() == 0 {
|
|
return int(min(a.GetUserId(), 1)) - int(min(b.GetUserId(), 1))
|
|
}
|
|
return strings.Compare(usernames[a.GetUserId()], usernames[b.GetUserId()])
|
|
}
|
|
return int(a.Metric) - int(b.Metric)
|
|
})
|
|
|
|
response := &apipb.ListUsageLimitsResponse{}
|
|
if offset < len(limits) {
|
|
end := min(offset+limit, len(limits))
|
|
for _, item := range limits[offset:end] {
|
|
response.UsageLimits = append(response.UsageLimits, convertUsageLimitFromStore(item, usernames[item.GetUserId()]))
|
|
}
|
|
if end < len(limits) {
|
|
response.NextPageToken, err = getPageToken(limit, end)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get next page token: %v", err)
|
|
}
|
|
}
|
|
}
|
|
return response, nil
|
|
}
|
|
|
|
// GetUsageLimit gets a usage limit. Admin only.
|
|
func (s *APIService) GetUsageLimit(ctx context.Context, request *apipb.GetUsageLimitRequest) (*apipb.UsageLimit, error) {
|
|
if _, err := s.requireUsageLimitAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
uid, err := ExtractUsageLimitIDFromName(request.Name)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid usage limit name: %v", err)
|
|
}
|
|
limits, usernames, err := s.listVisibleUsageLimits(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, limit := range limits {
|
|
if limit.Uid == uid {
|
|
return convertUsageLimitFromStore(limit, usernames[limit.GetUserId()]), nil
|
|
}
|
|
}
|
|
return nil, status.Errorf(codes.NotFound, "usage limit not found")
|
|
}
|
|
|
|
// CreateUsageLimit creates a usage limit. Admin only.
|
|
func (s *APIService) CreateUsageLimit(ctx context.Context, request *apipb.CreateUsageLimitRequest) (*apipb.UsageLimit, error) {
|
|
if _, err := s.requireUsageLimitAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if request.UsageLimit == nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "usage_limit is required")
|
|
}
|
|
uid, err := validateAndGenerateUsageLimitID(request.UsageLimitId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
metric := storepb.InstanceUsageLimitsSetting_Metric(request.UsageLimit.Metric)
|
|
if !store.IsValidUsageLimitMetric(metric) {
|
|
return nil, status.Errorf(codes.InvalidArgument, "metric must be MEMO_COUNT, STORAGE_BYTES, UPLOAD_BYTES, or MEMO_CONTENT_BYTES")
|
|
}
|
|
if request.UsageLimit.Value < 0 {
|
|
return nil, status.Errorf(codes.InvalidArgument, "value must not be negative")
|
|
}
|
|
var user *store.User
|
|
if request.UsageLimit.User != "" {
|
|
user, err = s.resolveUsageLimitUser(ctx, request.UsageLimit.User)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
create := &storepb.InstanceUsageLimitsSetting_UsageLimit{
|
|
Uid: uid,
|
|
Metric: metric,
|
|
Value: request.UsageLimit.Value,
|
|
Target: &storepb.InstanceUsageLimitsSetting_UsageLimit_AllUsers{AllUsers: &emptypb.Empty{}},
|
|
}
|
|
username := ""
|
|
if user != nil {
|
|
create.Target = &storepb.InstanceUsageLimitsSetting_UsageLimit_UserId{UserId: user.ID}
|
|
username = user.Username
|
|
}
|
|
created, err := s.Store.CreateUsageLimit(ctx, create)
|
|
if err != nil {
|
|
return nil, usageLimitStoreError(err)
|
|
}
|
|
return convertUsageLimitFromStore(created, username), nil
|
|
}
|
|
|
|
// UpdateUsageLimit updates the value of a usage limit. Admin only.
|
|
func (s *APIService) UpdateUsageLimit(ctx context.Context, request *apipb.UpdateUsageLimitRequest) (*apipb.UsageLimit, error) {
|
|
if _, err := s.requireUsageLimitAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if request.UsageLimit == nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "usage_limit is required")
|
|
}
|
|
uid, err := ExtractUsageLimitIDFromName(request.UsageLimit.Name)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid usage limit name: %v", err)
|
|
}
|
|
for _, path := range request.UpdateMask.GetPaths() {
|
|
if path != "value" {
|
|
return nil, status.Errorf(codes.InvalidArgument, "only value can be updated; %q is immutable or unknown", path)
|
|
}
|
|
}
|
|
if request.UsageLimit.Value < 0 {
|
|
return nil, status.Errorf(codes.InvalidArgument, "value must not be negative")
|
|
}
|
|
limits, usernames, err := s.listVisibleUsageLimits(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
index := slices.IndexFunc(limits, func(limit *storepb.InstanceUsageLimitsSetting_UsageLimit) bool { return limit.Uid == uid })
|
|
if index < 0 {
|
|
return nil, status.Errorf(codes.NotFound, "usage limit not found")
|
|
}
|
|
// metric and user are immutable. A request may echo them back unchanged.
|
|
current := limits[index]
|
|
if request.UsageLimit.Metric != apipb.UsageLimit_METRIC_UNSPECIFIED && storepb.InstanceUsageLimitsSetting_Metric(request.UsageLimit.Metric) != current.Metric {
|
|
return nil, status.Errorf(codes.InvalidArgument, "metric is immutable")
|
|
}
|
|
if request.UsageLimit.User != "" && request.UsageLimit.User != usageLimitUserName(usernames[current.GetUserId()]) {
|
|
return nil, status.Errorf(codes.InvalidArgument, "user is immutable")
|
|
}
|
|
updated, err := s.Store.UpdateUsageLimit(ctx, uid, request.UsageLimit.Value)
|
|
if err != nil {
|
|
return nil, usageLimitStoreError(err)
|
|
}
|
|
return convertUsageLimitFromStore(updated, usernames[updated.GetUserId()]), nil
|
|
}
|
|
|
|
// DeleteUsageLimit deletes a usage limit. Admin only.
|
|
func (s *APIService) DeleteUsageLimit(ctx context.Context, request *apipb.DeleteUsageLimitRequest) (*emptypb.Empty, error) {
|
|
if _, err := s.requireUsageLimitAdmin(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
uid, err := ExtractUsageLimitIDFromName(request.Name)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid usage limit name: %v", err)
|
|
}
|
|
if err := s.Store.DeleteUsageLimit(ctx, uid); err != nil {
|
|
return nil, usageLimitStoreError(err)
|
|
}
|
|
return &emptypb.Empty{}, nil
|
|
}
|
|
|
|
func (s *APIService) requireUsageLimitAdmin(ctx context.Context) (*store.User, error) {
|
|
user, err := s.fetchCurrentUser(ctx)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get current user: %v", err)
|
|
}
|
|
if user == nil {
|
|
return nil, status.Errorf(codes.Unauthenticated, "user not authenticated")
|
|
}
|
|
if user.Role != store.RoleAdmin {
|
|
return nil, status.Errorf(codes.PermissionDenied, "permission denied")
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
// listVisibleUsageLimits returns the stored usage limits, without those of
|
|
// users that no longer exist, and the usernames of the users they name.
|
|
func (s *APIService) listVisibleUsageLimits(ctx context.Context) ([]*storepb.InstanceUsageLimitsSetting_UsageLimit, map[int32]string, error) {
|
|
setting, err := s.Store.GetInstanceUsageLimitsSetting(ctx)
|
|
if err != nil {
|
|
return nil, nil, status.Errorf(codes.Internal, "failed to get usage limits: %v", err)
|
|
}
|
|
userIDs := []int32{}
|
|
for _, limit := range setting.GetLimits() {
|
|
if limit.GetUserId() != 0 && !slices.Contains(userIDs, limit.GetUserId()) {
|
|
userIDs = append(userIDs, limit.GetUserId())
|
|
}
|
|
}
|
|
usernames := map[int32]string{}
|
|
if len(userIDs) > 0 {
|
|
users, err := s.Store.ListUsers(ctx, &store.FindUser{IDList: userIDs})
|
|
if err != nil {
|
|
return nil, nil, status.Errorf(codes.Internal, "failed to list users: %v", err)
|
|
}
|
|
for _, user := range users {
|
|
usernames[user.ID] = user.Username
|
|
}
|
|
}
|
|
limits := make([]*storepb.InstanceUsageLimitsSetting_UsageLimit, 0, len(setting.GetLimits()))
|
|
for _, limit := range setting.GetLimits() {
|
|
if _, ok := usernames[limit.GetUserId()]; limit.GetUserId() != 0 && !ok {
|
|
continue
|
|
}
|
|
limits = append(limits, limit)
|
|
}
|
|
return limits, usernames, nil
|
|
}
|
|
|
|
func (s *APIService) resolveUsageLimitUser(ctx context.Context, name string) (*store.User, error) {
|
|
username, err := parseUsernameFromName(name)
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.InvalidArgument, "invalid user name: %v", err)
|
|
}
|
|
user, err := s.Store.GetUser(ctx, &store.FindUser{Username: &username})
|
|
if err != nil {
|
|
return nil, status.Errorf(codes.Internal, "failed to get user: %v", err)
|
|
}
|
|
if user == nil {
|
|
return nil, status.Errorf(codes.NotFound, "user not found")
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func usageLimitStoreError(err error) error {
|
|
switch {
|
|
case errors.Is(err, store.ErrUsageLimitNotFound):
|
|
return status.Errorf(codes.NotFound, "usage limit not found")
|
|
case errors.Is(err, store.ErrUsageLimitAlreadyExists):
|
|
return status.Error(codes.AlreadyExists, err.Error())
|
|
case errors.Is(err, store.ErrUsageLimitsDeploymentConfigured):
|
|
return status.Errorf(codes.FailedPrecondition, "usage limits are configured by the deployment")
|
|
case errors.Is(err, store.ErrUsageLimitWriteConflict):
|
|
return status.Errorf(codes.Aborted, "usage limits changed concurrently; retry")
|
|
case errors.Is(err, store.ErrInvalidUsageLimit):
|
|
return status.Error(codes.InvalidArgument, err.Error())
|
|
default:
|
|
return status.Errorf(codes.Internal, "failed to write usage limits: %v", err)
|
|
}
|
|
}
|
|
|
|
// validateAndGenerateUsageLimitID validates a client-chosen usage limit ID,
|
|
// or generates one.
|
|
func validateAndGenerateUsageLimitID(provided string) (string, error) {
|
|
if provided == "" {
|
|
return "limit-" + strings.ToLower(rand.Text()[:12]), nil
|
|
}
|
|
if len(provided) > 32 || !store.UsageLimitUIDMatcher.MatchString(provided) {
|
|
return "", status.Errorf(codes.InvalidArgument, "usage_limit_id must be lowercase kebab case, start with a letter, and have at most 32 characters")
|
|
}
|
|
return provided, nil
|
|
}
|
|
|
|
// checkMemoQuota refuses a new memo when the user has reached the memo limit.
|
|
func (s *APIService) checkMemoQuota(ctx context.Context, user *store.User) error {
|
|
return usageLimitCheckError(user.Username, usagelimit.CheckMemoCreate(ctx, s.Store, user.ID))
|
|
}
|
|
|
|
// checkMemoContentQuota refuses content larger than the memo owner's limit.
|
|
func (s *APIService) checkMemoContentQuota(ctx context.Context, userID int32, content string) error {
|
|
return s.userQuotaError(ctx, userID, usagelimit.CheckMemoContentSize(ctx, s.Store, userID, int64(len(content))))
|
|
}
|
|
|
|
// checkUploadQuota refuses an upload of size bytes that would break the
|
|
// per-file or storage limit of the user.
|
|
func (s *APIService) checkUploadQuota(ctx context.Context, userID int32, size int64) error {
|
|
return s.userQuotaError(ctx, userID, usagelimit.CheckUpload(ctx, s.Store, userID, size))
|
|
}
|
|
|
|
// checkFileSizeQuota refuses a file of size bytes that is larger than the
|
|
// per-file limit of the user. It runs no count or sum query.
|
|
func (s *APIService) checkFileSizeQuota(ctx context.Context, userID int32, size int64) error {
|
|
return s.userQuotaError(ctx, userID, usagelimit.CheckFileSize(ctx, s.Store, userID, size))
|
|
}
|
|
|
|
// userQuotaError maps a usage limit check result to a service error, naming the
|
|
// user in a refusal.
|
|
func (s *APIService) userQuotaError(ctx context.Context, userID int32, err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
username := ""
|
|
if usagelimit.AsRefusal(err) != nil {
|
|
user, userErr := s.Store.GetUser(ctx, &store.FindUser{ID: &userID})
|
|
if userErr == nil && user != nil {
|
|
username = user.Username
|
|
}
|
|
}
|
|
return usageLimitCheckError(username, err)
|
|
}
|
|
|
|
// usageLimitCheckError maps a usage limit check result to a service error.
|
|
// A failed check refuses the request: failing open would let a database
|
|
// problem switch the limits off.
|
|
func usageLimitCheckError(username string, err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if refusal := usagelimit.AsRefusal(err); refusal != nil {
|
|
return newQuotaExceededError(username, refusal)
|
|
}
|
|
return status.Errorf(codes.Internal, "failed to check usage limits: %v", err)
|
|
}
|
|
|
|
// usageLimitFilter is a parsed ListUsageLimits filter. A nil field matches
|
|
// every value.
|
|
type usageLimitFilter struct {
|
|
// username is "" for the defaults for every user.
|
|
username *string
|
|
userID *int32
|
|
metric *storepb.InstanceUsageLimitsSetting_Metric
|
|
}
|
|
|
|
// parseUsageLimitFilter parses `user == "users/{user}"`, `user == ""`, and
|
|
// `metric == "STORAGE_BYTES"` comparisons joined by `&&`.
|
|
func parseUsageLimitFilter(filter string) (*usageLimitFilter, error) {
|
|
result := &usageLimitFilter{}
|
|
filter = strings.TrimSpace(filter)
|
|
if filter == "" {
|
|
return result, nil
|
|
}
|
|
env, err := cel.NewEnv(cel.Variable("user", cel.StringType), cel.Variable("metric", cel.StringType))
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to create CEL environment")
|
|
}
|
|
compiled, issues := env.Compile(filter)
|
|
if issues != nil && issues.Err() != nil {
|
|
return nil, errors.Wrapf(issues.Err(), "invalid filter expression: %s", filter)
|
|
}
|
|
if err := result.add(compiled.NativeRep().Expr()); err != nil {
|
|
return nil, err
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (f *usageLimitFilter) add(expr ast.Expr) error {
|
|
if expr.Kind() != ast.CallKind {
|
|
return errors.New("filter must compare user or metric with a string")
|
|
}
|
|
call := expr.AsCall()
|
|
args := call.Args()
|
|
switch call.FunctionName() {
|
|
case "_&&_":
|
|
for _, arg := range args {
|
|
if err := f.add(arg); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
case "_==_":
|
|
default:
|
|
return errors.Errorf("unsupported operator %s; use == and &&", call.FunctionName())
|
|
}
|
|
if len(args) != 2 || args[0].Kind() != ast.IdentKind || args[1].Kind() != ast.LiteralKind {
|
|
return errors.New("filter must compare user or metric with a string")
|
|
}
|
|
value, ok := args[1].AsLiteral().Value().(string)
|
|
if !ok {
|
|
return errors.New("filter must compare user or metric with a string")
|
|
}
|
|
switch args[0].AsIdent() {
|
|
case "user":
|
|
username := ""
|
|
if value != "" {
|
|
parsed, err := parseUsernameFromName(value)
|
|
if err != nil {
|
|
return errors.Wrap(err, "invalid user")
|
|
}
|
|
username = parsed
|
|
}
|
|
f.username = &username
|
|
case "metric":
|
|
metric := storepb.InstanceUsageLimitsSetting_Metric(storepb.InstanceUsageLimitsSetting_Metric_value[value])
|
|
if !store.IsValidUsageLimitMetric(metric) {
|
|
return errors.Errorf("unknown metric %q", value)
|
|
}
|
|
f.metric = &metric
|
|
default:
|
|
return errors.Errorf("unknown field %q", args[0].AsIdent())
|
|
}
|
|
return nil
|
|
}
|