mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

Move cluster, webhub and store out of Server (#20899)

Просмотр исходного кода
Этот коммит содержится в:
Ibrahim Serdar Acikgoz
2022-10-06 11:04:21 +03:00
коммит произвёл GitHub
родитель 203df2f537
Коммит 5e69c6b02f
222 изменённых файлов: 9093 добавлений и 7710 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
app/users/errors.go
Просмотреть файл

@@ -12,10 +12,6 @@ var (
UserCreationDisabledError = errors.New("user creation is not allowed")
UserStoreIsEmptyError = errors.New("could not check if the user store is empty")
GetTokenError = errors.New("could not get token")
GetSessionError = errors.New("could not get session")
DeleteTokenError = errors.New("could not delete token")
DeleteSessionError = errors.New("could not delete session")
DeleteAllAccessDataError = errors.New("could not delete all access data")
DefaultFontError = errors.New("could not get default font")

17
app/users/helper_test.go
Просмотреть файл

@@ -7,14 +7,12 @@ import (
"bytes"
"os"
"path/filepath"
"runtime"
"sync"
"testing"
"github.com/mattermost/mattermost-server/v6/app/request"
"github.com/mattermost/mattermost-server/v6/config"
"github.com/mattermost/mattermost-server/v6/model"
"github.com/mattermost/mattermost-server/v6/services/cache"
"github.com/mattermost/mattermost-server/v6/store"
)
@@ -73,27 +71,12 @@ func setupTestHelper(s store.Store, includeCacheLayer bool, tb testing.TB) *Test
configStore.Set(config)
buffer := &bytes.Buffer{}
provider := cache.NewProvider()
cache, err := provider.NewCache(&cache.CacheOptions{
Size: model.SessionCacheSize,
Striped: true,
StripedBuckets: maxInt(runtime.NumCPU()-1, 1),
})
if err != nil {
panic(err)
}
return &TestHelper{
service: &UserService{
store: s.User(),
sessionStore: s.Session(),
oAuthStore: s.OAuth(),
sessionCache: cache,
config: configStore.Get,
sessionPool: sync.Pool{
New: func() any {
return &model.Session{}
},
},
},
Context: request.EmptyContext(nil),
configStore: configStore,

26
app/users/service.go
Просмотреть файл

@@ -5,13 +5,9 @@ package users
import (
"errors"
"fmt"
"runtime"
"sync"
"github.com/mattermost/mattermost-server/v6/einterfaces"
"github.com/mattermost/mattermost-server/v6/model"
"github.com/mattermost/mattermost-server/v6/services/cache"
"github.com/mattermost/mattermost-server/v6/store"
)
@@ -19,8 +15,6 @@ type UserService struct {
store store.UserStore
sessionStore store.SessionStore
oAuthStore store.OAuthStore
sessionCache cache.Cache
sessionPool sync.Pool
metrics einterfaces.MetricsInterface
cluster einterfaces.ClusterInterface
config func() *model.Config
@@ -45,20 +39,6 @@ func New(c ServiceConfig) (*UserService, error) {
return nil, err
}
cacheProvider := cache.NewProvider()
if err := cacheProvider.Connect(); err != nil {
return nil, fmt.Errorf("could not connect to cache provider: %w", err)
}
sessionCache, err := cacheProvider.NewCache(&cache.CacheOptions{
Size: model.SessionCacheSize,
Striped: true,
StripedBuckets: maxInt(runtime.NumCPU()-1, 1),
})
if err != nil {
return nil, fmt.Errorf("could not create session cache: %w", err)
}
return &UserService{
store: c.UserStore,
sessionStore: c.SessionStore,
@@ -67,12 +47,6 @@ func New(c ServiceConfig) (*UserService, error) {
license: c.LicenseFn,
metrics: c.Metrics,
cluster: c.Cluster,
sessionCache: sessionCache,
sessionPool: sync.Pool{
New: func() any {
return &model.Session{}
},
},
}, nil
}

263
app/users/session.go
Просмотреть файл

@@ -1,263 +0,0 @@
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
package users
import (
"context"
"fmt"
"time"
"github.com/mattermost/mattermost-server/v6/model"
"github.com/mattermost/mattermost-server/v6/shared/mlog"
"github.com/mattermost/mattermost-server/v6/store/sqlstore"
"github.com/pkg/errors"
)
func (us *UserService) ReturnSessionToPool(session *model.Session) {
if session != nil {
session.Id = ""
us.sessionPool.Put(session)
}
}
func (us *UserService) CreateSession(session *model.Session) (*model.Session, error) {
session.Token = ""
session, err := us.sessionStore.Save(session)
if err != nil {
return nil, err
}
us.AddSessionToCache(session)
return session, nil
}
func (us *UserService) GetSession(token string) (*model.Session, error) {
var session = us.sessionPool.Get().(*model.Session)
if err := us.sessionCache.Get(token, session); err == nil {
if us.metrics != nil {
us.metrics.IncrementMemCacheHitCounterSession()
}
} else {
if us.metrics != nil {
us.metrics.IncrementMemCacheMissCounterSession()
}
}
if session.Id != "" {
return session, nil
}
return us.GetSessionContext(sqlstore.WithMaster(context.Background()), token)
}
func (us *UserService) GetSessionContext(ctx context.Context, token string) (*model.Session, error) {
return us.sessionStore.Get(ctx, token)
}
func (us *UserService) GetSessions(userID string) ([]*model.Session, error) {
return us.sessionStore.GetSessions(userID)
}
func (us *UserService) AddSessionToCache(session *model.Session) {
us.sessionCache.SetWithExpiry(session.Token, session, time.Duration(int64(*us.config().ServiceSettings.SessionCacheInMinutes))*time.Minute)
}
func (us *UserService) SessionCacheLength() int {
if l, err := us.sessionCache.Len(); err == nil {
return l
}
return 0
}
func (us *UserService) ClearUserSessionCacheLocal(userID string) {
if keys, err := us.sessionCache.Keys(); err == nil {
var session *model.Session
for _, key := range keys {
if err := us.sessionCache.Get(key, &session); err == nil {
if session.UserId == userID {
us.sessionCache.Remove(key)
if us.metrics != nil {
us.metrics.IncrementMemCacheInvalidationCounterSession()
}
}
}
}
}
}
func (us *UserService) ClearAllUsersSessionCacheLocal() {
us.sessionCache.Purge()
}
func (us *UserService) ClearUserSessionCache(userID string) {
us.ClearUserSessionCacheLocal(userID)
if us.cluster != nil {
msg := &model.ClusterMessage{
Event: model.ClusterEventClearSessionCacheForUser,
SendType: model.ClusterSendReliable,
Data: []byte(userID),
}
us.cluster.SendClusterMessage(msg)
}
}
func (us *UserService) ClearAllUsersSessionCache() {
us.ClearAllUsersSessionCacheLocal()
if us.cluster != nil {
msg := &model.ClusterMessage{
Event: model.ClusterEventClearSessionCacheForAllUsers,
SendType: model.ClusterSendReliable,
}
us.cluster.SendClusterMessage(msg)
}
}
func (us *UserService) GetSessionByID(sessionID string) (*model.Session, error) {
return us.sessionStore.Get(context.Background(), sessionID)
}
func (us *UserService) RevokeSessionsFromAllUsers() error {
// revoke tokens before sessions so they can't be used to relogin
nErr := us.oAuthStore.RemoveAllAccessData()
if nErr != nil {
return errors.Wrap(DeleteAllAccessDataError, nErr.Error())
}
err := us.sessionStore.RemoveAllSessions()
if err != nil {
return err
}
us.ClearAllUsersSessionCache()
return nil
}
func (us *UserService) RevokeSessionsForDeviceId(userID string, deviceID string, currentSessionId string) error {
sessions, err := us.sessionStore.GetSessions(userID)
if err != nil {
return err
}
for _, session := range sessions {
if session.DeviceId == deviceID && session.Id != currentSessionId {
mlog.Debug("Revoking sessionId for userId. Re-login with the same device Id", mlog.String("session_id", session.Id), mlog.String("user_id", userID))
if err := us.RevokeSession(session); err != nil {
mlog.Warn("Could not revoke session for device", mlog.String("device_id", deviceID), mlog.Err(err))
}
}
}
return nil
}
func (us *UserService) RevokeSession(session *model.Session) error {
if session.IsOAuth {
if err := us.RevokeAccessToken(session.Token); err != nil {
return err
}
} else {
if err := us.sessionStore.Remove(session.Id); err != nil {
return errors.Wrap(DeleteSessionError, err.Error())
}
}
us.ClearUserSessionCache(session.UserId)
return nil
}
func (us *UserService) RevokeAccessToken(token string) error {
session, _ := us.GetSession(token)
defer us.ReturnSessionToPool(session)
schan := make(chan error, 1)
go func() {
schan <- us.sessionStore.Remove(token)
close(schan)
}()
if _, err := us.oAuthStore.GetAccessData(token); err != nil {
return errors.Wrap(GetTokenError, err.Error())
}
if err := us.oAuthStore.RemoveAccessData(token); err != nil {
return errors.Wrap(DeleteTokenError, err.Error())
}
if err := <-schan; err != nil {
return errors.Wrap(DeleteSessionError, err.Error())
}
if session != nil {
us.ClearUserSessionCache(session.UserId)
}
return nil
}
// SetSessionExpireInHours sets the session's expiry the specified number of hours
// relative to either the session creation date or the current time, depending
// on the `ExtendSessionOnActivity` config setting.
func (us *UserService) SetSessionExpireInHours(session *model.Session, hours int) {
if session.CreateAt == 0 || *us.config().ServiceSettings.ExtendSessionLengthWithActivity {
session.ExpiresAt = model.GetMillis() + (1000 * 60 * 60 * int64(hours))
} else {
session.ExpiresAt = session.CreateAt + (1000 * 60 * 60 * int64(hours))
}
}
func (us *UserService) ExtendSessionExpiry(session *model.Session, newExpiry int64) error {
if err := us.sessionStore.UpdateExpiresAt(session.Id, newExpiry); err != nil {
return err
}
// Update local cache. No need to invalidate cache for cluster as the session cache timeout
// ensures each node will get an extended expiry within the next 10 minutes.
// Worst case is another node may generate a redundant expiry update.
session.ExpiresAt = newExpiry
us.AddSessionToCache(session)
return nil
}
func (us *UserService) UpdateSessionsIsGuest(userID string, isGuest bool) error {
sessions, err := us.GetSessions(userID)
if err != nil {
return err
}
for _, session := range sessions {
session.AddProp(model.SessionPropIsGuest, fmt.Sprintf("%t", isGuest))
err := us.sessionStore.UpdateProps(session)
if err != nil {
mlog.Warn("Unable to update isGuest session", mlog.Err(err))
continue
}
us.AddSessionToCache(session)
}
return nil
}
func (us *UserService) RevokeAllSessions(userID string) error {
sessions, err := us.sessionStore.GetSessions(userID)
if err != nil {
return errors.Wrap(GetSessionError, err.Error())
}
for _, session := range sessions {
if session.IsOAuth {
us.RevokeAccessToken(session.Token)
} else {
if err := us.sessionStore.Remove(session.Id); err != nil {
return errors.Wrap(DeleteSessionError, err.Error())
}
}
}
us.ClearUserSessionCache(userID)
return nil
}

133
app/users/session_test.go
Просмотреть файл

@@ -1,133 +0,0 @@
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
package users
import (
"testing"
"time"
"github.com/mattermost/mattermost-server/v6/model"
"github.com/stretchr/testify/require"
)
const (
dayInMillis = 86400000
grace = 5 * 1000
thirtyDays = dayInMillis * 30
)
func TestCache(t *testing.T) {
th := Setup(t)
defer th.TearDown()
session := &model.Session{
Id: model.NewId(),
Token: model.NewId(),
UserId: model.NewId(),
}
session2 := &model.Session{
Id: model.NewId(),
Token: model.NewId(),
UserId: model.NewId(),
}
th.service.sessionCache.SetWithExpiry(session.Token, session, 5*time.Minute)
th.service.sessionCache.SetWithExpiry(session2.Token, session2, 5*time.Minute)
keys, err := th.service.sessionCache.Keys()
require.NoError(t, err)
require.NotEmpty(t, keys)
th.service.ClearUserSessionCache(session.UserId)
rkeys, err := th.service.sessionCache.Keys()
require.NoError(t, err)
require.Lenf(t, rkeys, len(keys)-1, "should have one less: %d - %d != 1", len(keys), len(rkeys))
require.NotEmpty(t, rkeys)
th.service.ClearAllUsersSessionCache()
rkeys, err = th.service.sessionCache.Keys()
require.NoError(t, err)
require.Empty(t, rkeys)
}
func TestSetSessionExpireInHours(t *testing.T) {
th := Setup(t)
defer th.TearDown()
now := model.GetMillis()
createAt := now - (dayInMillis * 20)
tests := []struct {
name string
extend bool
create bool
days int
want int64
}{
{name: "zero days, extend", extend: true, create: true, days: 0, want: now},
{name: "zero days, extend", extend: true, create: false, days: 0, want: now},
{name: "zero days, no extend", extend: false, create: true, days: 0, want: createAt},
{name: "zero days, no extend", extend: false, create: false, days: 0, want: now},
{name: "thirty days, extend", extend: true, create: true, days: 30, want: now + thirtyDays},
{name: "thirty days, extend", extend: true, create: false, days: 30, want: now + thirtyDays},
{name: "thirty days, no extend", extend: false, create: true, days: 30, want: createAt + thirtyDays},
{name: "thirty days, no extend", extend: false, create: false, days: 30, want: now + thirtyDays},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
th.UpdateConfig(func(cfg *model.Config) {
*cfg.ServiceSettings.ExtendSessionLengthWithActivity = tt.extend
})
var create int64
if tt.create {
create = createAt
}
session := &model.Session{
CreateAt: create,
ExpiresAt: model.GetMillis() + dayInMillis,
}
th.service.SetSessionExpireInHours(session, tt.days*24)
// must be within 5 seconds of expected time.
require.GreaterOrEqual(t, session.ExpiresAt, tt.want-grace)
require.LessOrEqual(t, session.ExpiresAt, tt.want+grace)
})
}
}
func TestOAuthRevokeAccessToken(t *testing.T) {
th := Setup(t)
defer th.TearDown()
err := th.service.RevokeAccessToken(model.NewRandomString(16))
require.Error(t, err, "Should have failed due to an incorrect token")
session := &model.Session{}
session.CreateAt = model.GetMillis()
session.UserId = model.NewId()
session.Token = model.NewId()
session.Roles = model.SystemUserRoleId
th.service.SetSessionExpireInHours(session, 24)
session, _ = th.service.CreateSession(session)
err = th.service.RevokeAccessToken(session.Token)
require.Error(t, err, "Should have failed does not have an access token")
accessData := &model.AccessData{}
accessData.Token = session.Token
accessData.UserId = session.UserId
accessData.RedirectUri = "http://example.com"
accessData.ClientId = model.NewId()
accessData.ExpiresAt = session.ExpiresAt
_, nErr := th.service.oAuthStore.SaveAccessData(accessData)
require.NoError(t, nErr)
err = th.service.RevokeAccessToken(accessData.Token)
require.NoError(t, err)
}

6
app/users/users.go
Просмотреть файл

@@ -207,12 +207,6 @@ func (us *UserService) DeactivateAllGuests() ([]string, error) {
return nil, err
}
for _, userID := range users {
if err := us.RevokeAllSessions(userID); err != nil {
return nil, err
}
}
return users, nil
}

25
app/users/utils.go
Просмотреть файл

@@ -9,31 +9,6 @@ import (
"github.com/mattermost/mattermost-server/v6/model"
)
func maxInt(a, b int) int {
if a > b {
return a
}
return b
}
func (us *UserService) IsFirstUserAccount() bool {
cachedSessions, err := us.sessionCache.Len()
if err != nil {
return false
}
if cachedSessions == 0 {
count, err := us.store.Count(model.UserCountOptions{IncludeDeleted: true})
if err != nil {
return false
}
if count <= 0 {
return true
}
}
return false
}
// CheckUserDomain checks that a user's email domain matches a list of space-delimited domains as a string.
func CheckUserDomain(user *model.User, domains string) bool {
return CheckEmailDomain(user.Email, domains)