snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/channels/app/limits.go

@@ -0,0 +1,125 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"net/http"
+
+	"github.com/mattermost/mattermost/server/public/model"
+)
+
+const (
+	maxUsersLimit     = 200
+	maxUsersHardLimit = 250
+)
+
+// GetServerLimits returns the server's seat/post-history limits. The license-derived
+// limit fields and post-history fields are always computed (they are cheap and needed
+// by all users). The active user and single-channel guest counts are only computed when
+// includeUserCounts is true, because those queries are expensive and the counts are only
+// consumed by admin-gated UI and internal seat-limit checks. Callers that do not need the
+// counts (e.g. non-admin API requests) should pass false to keep the expensive queries off
+// the hot path.
+func (a *App) GetServerLimits(includeUserCounts bool) (*model.ServerLimits, *model.AppError) {
+	limits := &model.ServerLimits{}
+	license := a.License()
+
+	if license == nil && maxUsersLimit > 0 {
+		// Enforce hard-coded limits for unlicensed servers (no grace period).
+		limits.MaxUsersLimit = maxUsersLimit
+		limits.MaxUsersHardLimit = maxUsersHardLimit
+	} else if license != nil && license.IsSeatCountEnforced && license.Features != nil && license.Features.Users != nil {
+		// Enforce license limits as required by the license with configurable extra users.
+		licenseUserLimit := int64(*license.Features.Users)
+		limits.MaxUsersLimit = licenseUserLimit
+
+		// Use ExtraUsers if configured, otherwise default to 0 (no extra users)
+		extraUsers := 0
+		if license.ExtraUsers != nil {
+			extraUsers = *license.ExtraUsers
+		}
+
+		limits.MaxUsersHardLimit = licenseUserLimit + int64(extraUsers)
+	}
+
+	// Check if license has post history limits and get the calculated timestamp
+	if license != nil && license.Limits != nil && license.Limits.PostHistory > 0 {
+		limits.PostHistoryLimit = license.Limits.PostHistory
+		// Get the calculated timestamp of the last accessible post
+		lastAccessibleTime, appErr := a.GetLastAccessiblePostTime()
+		if appErr != nil {
+			return nil, appErr
+		}
+		limits.LastAccessiblePostTime = lastAccessibleTime
+	}
+
+	// The user/guest count queries are expensive (the single-channel guest count is a
+	// full ChannelMembers scan). Only run them when the caller actually needs the counts.
+	if !includeUserCounts {
+		return limits, nil
+	}
+
+	activeUserCount, appErr := a.Srv().Store().User().Count(model.UserCountOptions{})
+	if appErr != nil {
+		return nil, model.NewAppError("GetServerLimits", "app.limits.get_app_limits.user_count.store_error", nil, "", http.StatusInternalServerError).Wrap(appErr)
+	}
+
+	if a.shouldTrackSingleChannelGuests() {
+		singleChannelGuestCount, err := a.Srv().Store().User().AnalyticsGetSingleChannelGuestCount()
+		if err != nil {
+			return nil, model.NewAppError("GetServerLimits", "app.limits.get_app_limits.single_channel_guest_count.store_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+
+		// Single-channel guests are free and excluded from the primary seat count.
+		limits.ActiveUserCount = max(activeUserCount-singleChannelGuestCount, 0)
+		limits.SingleChannelGuestCount = singleChannelGuestCount
+		// Guests are allowed up to a 1:1 ratio with licensed seats.
+		if license != nil && license.Features != nil && license.Features.Users != nil {
+			limits.SingleChannelGuestLimit = int64(*license.Features.Users)
+		}
+	} else {
+		limits.ActiveUserCount = activeUserCount
+	}
+
+	return limits, nil
+}
+
+func (a *App) shouldTrackSingleChannelGuests() bool {
+	license := a.License()
+	if license == nil {
+		return false
+	}
+	if license.IsMattermostEntry() {
+		return false
+	}
+	cfg := a.Config()
+	if cfg == nil || cfg.GuestAccountsSettings.Enable == nil {
+		return false
+	}
+
+	return *cfg.GuestAccountsSettings.Enable
+}
+
+func (a *App) GetPostHistoryLimit() int64 {
+	license := a.License()
+	if license == nil || license.Limits == nil || license.Limits.PostHistory == 0 {
+		// No limits applicable
+		return 0
+	}
+
+	return license.Limits.PostHistory
+}
+
+func (a *App) isAtUserLimit() (bool, *model.AppError) {
+	userLimits, appErr := a.GetServerLimits(true)
+	if appErr != nil {
+		return false, appErr
+	}
+
+	if userLimits.MaxUsersHardLimit == 0 {
+		return false, nil
+	}
+
+	return userLimits.ActiveUserCount >= userLimits.MaxUsersHardLimit, appErr
+}