From bfaf4fa5dcbb0b56440245232f34d0a1059c6834 Mon Sep 17 00:00:00 2001 From: Agniva De Sarker Date: Wed, 5 Feb 2020 11:31:39 +0530 Subject: [PATCH] MM-22105: Revert "MM-21210: Add LRU cache for ChannelStore.GetMembersForUser (#13593)" (#13784) This reverts commit 0361e8b97ed40648d36d06c8af7823509446cf5c. The new cache ultimately did not give much benefit because the hit rate was pretty low and it did not lead to any reduction in store timings. So the increase in cluster messages was not worth it. Co-authored-by: mattermod --- model/cluster_message.go | 1 - services/cache/cache.go | 3 - services/cache/lru/lru.go | 18 --- store/localcachelayer/channel_layer.go | 136 -------------------- store/localcachelayer/channel_layer_test.go | 66 +--------- store/localcachelayer/layer.go | 93 ++++--------- store/localcachelayer/main_test.go | 13 -- 7 files changed, 27 insertions(+), 303 deletions(-) diff --git a/model/cluster_message.go b/model/cluster_message.go index a7c8d8834d..ec62eb7588 100644 --- a/model/cluster_message.go +++ b/model/cluster_message.go @@ -17,7 +17,6 @@ const ( CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_POSTS = "inv_channel_posts" CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBERS_NOTIFY_PROPS = "inv_channel_members_notify_props" CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBERS = "inv_channel_members" - CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBERS_FOR_USER = "inv_channel_members_user" CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_BY_NAME = "inv_channel_name" CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL = "inv_channel" CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_GUEST_COUNT = "inv_channel_guest_count" diff --git a/services/cache/cache.go b/services/cache/cache.go index 87f1cecdf7..da3581f6bd 100644 --- a/services/cache/cache.go +++ b/services/cache/cache.go @@ -31,9 +31,6 @@ type Cache interface { // Remove deletes the value for a key. Remove(key string) - // RemoveByPrefix deletes all keys containing the given prefix string. - RemoveByPrefix(prefix string) - // Keys returns a slice of the keys in the cache. Keys() []string diff --git a/services/cache/lru/lru.go b/services/cache/lru/lru.go index 432ba0d944..a527c05636 100644 --- a/services/cache/lru/lru.go +++ b/services/cache/lru/lru.go @@ -12,7 +12,6 @@ package lru import ( "container/list" - "strings" "sync" "time" @@ -188,23 +187,6 @@ func (c *Cache) Remove(key string) { } } -// RemoveByPrefix deletes all keys containing the given prefix string. -func (c *Cache) RemoveByPrefix(prefix string) { - c.lock.Lock() - defer c.lock.Unlock() - - for ent := c.evictList.Back(); ent != nil; ent = ent.Prev() { - e := ent.Value.(*entry) - if e.generation == c.currentGeneration { - if strings.HasPrefix(e.key, prefix) { - if ent, ok := c.items[e.key]; ok { - c.removeElement(ent) - } - } - } - } -} - // Keys returns a slice of the keys in the cache, from oldest to newest. func (c *Cache) Keys() []string { c.lock.RLock() diff --git a/store/localcachelayer/channel_layer.go b/store/localcachelayer/channel_layer.go index 5d191f80fa..75d751fd73 100644 --- a/store/localcachelayer/channel_layer.go +++ b/store/localcachelayer/channel_layer.go @@ -45,29 +45,17 @@ func (s *LocalCacheChannelStore) handleClusterInvalidateChannelById(msg *model.C } } -func (s *LocalCacheChannelStore) handleClusterInvalidateChannelMembersForUser(msg *model.ClusterMessage) { - if msg.Data == CLEAR_CACHE_MESSAGE_DATA { - s.rootStore.channelMembersForUserCache.Purge() - return - } - - // Remove keys with prefix msg.Data - s.rootStore.channelMembersForUserCache.RemoveByPrefix(msg.Data) -} - func (s LocalCacheChannelStore) ClearCaches() { s.rootStore.doClearCacheCluster(s.rootStore.channelMemberCountsCache) s.rootStore.doClearCacheCluster(s.rootStore.channelPinnedPostCountsCache) s.rootStore.doClearCacheCluster(s.rootStore.channelGuestCountCache) s.rootStore.doClearCacheCluster(s.rootStore.channelByIdCache) - s.rootStore.doClearCacheCluster(s.rootStore.channelMembersForUserCache) s.ChannelStore.ClearCaches() if s.rootStore.metrics != nil { s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Pinned Post Counts - Purge") s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Member Counts - Purge") s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Guest Count - Purge") s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel - Purge") - s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Members For User - Purge") } } @@ -85,44 +73,6 @@ func (s LocalCacheChannelStore) InvalidateMemberCount(channelId string) { } } -// invalidateMembersForUser removes all keys from channelMembersForUserCache -// with the prefix of the given userID. -// We cannot simply call doInvalidateCacheCluster because we need to remove -// keys with a prefix rather than remove a single key. -func (s LocalCacheChannelStore) invalidateMembersForUser(userId string) { - s.rootStore.channelMembersForUserCache.RemoveByPrefix(userId) - if s.rootStore.cluster != nil { - msg := &model.ClusterMessage{ - Event: model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBERS_FOR_USER, - SendType: model.CLUSTER_SEND_BEST_EFFORT, - Data: userId, - } - s.rootStore.cluster.SendClusterMessage(msg) - } - - if s.rootStore.metrics != nil { - s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Members For User - Remove by UserId") - } -} - -// invalidateMembersForAllUsers purges the entire channelMembersForUserCache cache. -func (s LocalCacheChannelStore) invalidateMembersForAllUsers() { - s.rootStore.channelMembersForUserCache.Purge() - - if s.rootStore.cluster != nil { - msg := &model.ClusterMessage{ - Event: model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBERS_FOR_USER, - SendType: model.CLUSTER_SEND_BEST_EFFORT, - Data: CLEAR_CACHE_MESSAGE_DATA, - } - s.rootStore.cluster.SendClusterMessage(msg) - } - - if s.rootStore.metrics != nil { - s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Members For User - Purge") - } -} - func (s LocalCacheChannelStore) InvalidateGuestCount(channelId string) { s.rootStore.doInvalidateCacheCluster(s.rootStore.channelGuestCountCache, channelId) if s.rootStore.metrics != nil { @@ -200,92 +150,6 @@ func (s LocalCacheChannelStore) GetPinnedPostCount(channelId string, allowFromCa return count, nil } -// SaveMember is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) SaveMember(member *model.ChannelMember) (*model.ChannelMember, *model.AppError) { - defer s.invalidateMembersForUser(member.UserId) - return s.ChannelStore.SaveMember(member) -} - -// UpdateMember is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) UpdateMember(member *model.ChannelMember) (*model.ChannelMember, *model.AppError) { - defer s.invalidateMembersForUser(member.UserId) - return s.ChannelStore.UpdateMember(member) -} - -// RemoveMember is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) RemoveMember(channelId, userId string) *model.AppError { - defer s.invalidateMembersForUser(userId) - return s.ChannelStore.RemoveMember(channelId, userId) -} - -// UpdateLastViewedAt is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) UpdateLastViewedAt(channelIds []string, userId string) (map[string]int64, *model.AppError) { - defer s.invalidateMembersForUser(userId) - return s.ChannelStore.UpdateLastViewedAt(channelIds, userId) -} - -// UpdateLastViewedAtPost is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) UpdateLastViewedAtPost(unreadPost *model.Post, userID string, mentionCount int) (*model.ChannelUnreadAt, *model.AppError) { - defer s.invalidateMembersForUser(userID) - return s.ChannelStore.UpdateLastViewedAtPost(unreadPost, userID, mentionCount) -} - -// PermanentDeleteMembersByChannel is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) PermanentDeleteMembersByChannel(channelId string) *model.AppError { - defer s.invalidateMembersForAllUsers() - return s.ChannelStore.PermanentDeleteMembersByChannel(channelId) -} - -// PermanentDeleteMembersByUser is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) PermanentDeleteMembersByUser(userId string) *model.AppError { - defer s.invalidateMembersForUser(userId) - return s.ChannelStore.PermanentDeleteMembersByUser(userId) -} - -// RemoveAllDeactivatedMembers is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) RemoveAllDeactivatedMembers(channelId string) *model.AppError { - defer s.invalidateMembersForAllUsers() - return s.ChannelStore.RemoveAllDeactivatedMembers(channelId) -} - -// ClearAllCustomRoleAssignments is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) ClearAllCustomRoleAssignments() *model.AppError { - defer s.invalidateMembersForAllUsers() - return s.ChannelStore.ClearAllCustomRoleAssignments() -} - -// IncrementMentionCount is a wrapper method for the underlying store which just takes -// care of the cache invalidation. -func (s LocalCacheChannelStore) IncrementMentionCount(channelId, userId string) *model.AppError { - defer s.invalidateMembersForUser(userId) - return s.ChannelStore.IncrementMentionCount(channelId, userId) -} - -// GetMembersForUser is a cache wrapper method for ChannelStore. -func (s LocalCacheChannelStore) GetMembersForUser(teamId, userId string) (*model.ChannelMembers, *model.AppError) { - key := userId + "-" + teamId - if members := s.rootStore.doStandardReadCache(s.rootStore.channelMembersForUserCache, key); members != nil { - return members.(*model.ChannelMembers), nil - } - - members, err := s.ChannelStore.GetMembersForUser(teamId, userId) - if err != nil { - return nil, err - } - - s.rootStore.doStandardAddToCache(s.rootStore.channelMembersForUserCache, key, members) - return members, nil -} - func (s LocalCacheChannelStore) Get(id string, allowFromCache bool) (*model.Channel, *model.AppError) { if allowFromCache { diff --git a/store/localcachelayer/channel_layer_test.go b/store/localcachelayer/channel_layer_test.go index 894849823d..ef3046d2ac 100644 --- a/store/localcachelayer/channel_layer_test.go +++ b/store/localcachelayer/channel_layer_test.go @@ -4,9 +4,8 @@ package localcachelayer import ( - "testing" - "github.com/mattermost/mattermost-server/v5/model" + "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -297,66 +296,3 @@ func TestChannelStoreChannel(t *testing.T) { mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 2) }) } - -func TestChannelStoreChannelMembersForUserCache(t *testing.T) { - fakeChannelMembers := model.ChannelMembers([]model.ChannelMember{ - { - UserId: "123", - }, - }) - - t.Run("first call not cached, second cached and returning same data", func(t *testing.T) { - mockStore := getMockStore() - mockCacheProvider := getMockCacheProvider() - cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) - - gotMembers, err := cachedStore.Channel().GetMembersForUser("teamId", "userId1") - require.Nil(t, err) - assert.Equal(t, &fakeChannelMembers, gotMembers) - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 1) - - _, _ = cachedStore.Channel().GetMembersForUser("teamId", "userId1") - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 1) - }) - - t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) { - mockStore := getMockStore() - mockCacheProvider := getMockCacheProvider() - cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) - - gotMembers, err := cachedStore.Channel().GetMembersForUser("teamId", "userId1") - require.Nil(t, err) - assert.Equal(t, &fakeChannelMembers, gotMembers) - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 1) - - // invalidate - cachedStore.Channel().(LocalCacheChannelStore).invalidateMembersForUser("userId1") - - _, _ = cachedStore.Channel().GetMembersForUser("teamId", "userId1") - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 2) - }) - - t.Run("cache multiple items, invalidate all, then nothing cached ", func(t *testing.T) { - mockStore := getMockStore() - mockCacheProvider := getMockCacheProvider() - cachedStore := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider) - - gotMembers, err := cachedStore.Channel().GetMembersForUser("teamId", "userId1") - require.Nil(t, err) - assert.Equal(t, &fakeChannelMembers, gotMembers) - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 1) - - gotMembers, err = cachedStore.Channel().GetMembersForUser("teamId", "userId2") - require.Nil(t, err) - assert.Equal(t, &fakeChannelMembers, gotMembers) - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 2) - - // invalidate all - cachedStore.Channel().(LocalCacheChannelStore).invalidateMembersForAllUsers() - - _, _ = cachedStore.Channel().GetMembersForUser("teamId", "userId1") - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 3) - _, _ = cachedStore.Channel().GetMembersForUser("teamId", "userId2") - mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMembersForUser", 4) - }) -} diff --git a/store/localcachelayer/layer.go b/store/localcachelayer/layer.go index 495ab29c04..1c4085e049 100644 --- a/store/localcachelayer/layer.go +++ b/store/localcachelayer/layer.go @@ -35,9 +35,6 @@ const ( CHANNEL_MEMBERS_COUNTS_CACHE_SIZE = model.CHANNEL_CACHE_SIZE CHANNEL_MEMBERS_COUNTS_CACHE_SEC = 30 * 60 - CHANNEL_MEMBERS_FOR_USER_SIZE = model.CHANNEL_CACHE_SIZE - CHANNEL_MEMBERS_FOR_USER_CACHE_SEC = 30 * 60 - LAST_POSTS_CACHE_SIZE = 20000 LAST_POSTS_CACHE_SEC = 30 * 60 @@ -62,45 +59,34 @@ const ( type LocalCacheStore struct { store.Store - metrics einterfaces.MetricsInterface - cluster einterfaces.ClusterInterface - - reaction LocalCacheReactionStore - reactionCache cache.Cache - - role LocalCacheRoleStore - roleCache cache.Cache - - scheme LocalCacheSchemeStore - schemeCache cache.Cache - - emoji LocalCacheEmojiStore - emojiCacheById cache.Cache - emojiIdCacheByName cache.Cache - + metrics einterfaces.MetricsInterface + cluster einterfaces.ClusterInterface + reaction LocalCacheReactionStore + reactionCache cache.Cache + role LocalCacheRoleStore + roleCache cache.Cache + scheme LocalCacheSchemeStore + schemeCache cache.Cache + emoji LocalCacheEmojiStore + emojiCacheById cache.Cache + emojiIdCacheByName cache.Cache channel LocalCacheChannelStore channelMemberCountsCache cache.Cache channelGuestCountCache cache.Cache channelPinnedPostCountsCache cache.Cache channelByIdCache cache.Cache - channelMembersForUserCache cache.Cache - - webhook LocalCacheWebhookStore - webhookCache cache.Cache - - post LocalCachePostStore - postLastPostsCache cache.Cache - lastPostTimeCache cache.Cache - - user LocalCacheUserStore - userProfileByIdsCache cache.Cache - profilesInChannelCache cache.Cache - - team LocalCacheTeamStore - teamAllTeamIdsForUserCache cache.Cache - - termsOfService LocalCacheTermsOfServiceStore - termsOfServiceCache cache.Cache + webhook LocalCacheWebhookStore + webhookCache cache.Cache + post LocalCachePostStore + postLastPostsCache cache.Cache + lastPostTimeCache cache.Cache + user LocalCacheUserStore + userProfileByIdsCache cache.Cache + profilesInChannelCache cache.Cache + team LocalCacheTeamStore + teamAllTeamIdsForUserCache cache.Cache + termsOfService LocalCacheTermsOfServiceStore + termsOfServiceCache cache.Cache } func NewLocalCacheLayer(baseStore store.Store, metrics einterfaces.MetricsInterface, cluster einterfaces.ClusterInterface, cacheProvider cache.Provider) LocalCacheStore { @@ -110,80 +96,54 @@ func NewLocalCacheLayer(baseStore store.Store, metrics einterfaces.MetricsInterf cluster: cluster, metrics: metrics, } - - // Reactions localCacheStore.reactionCache = cacheProvider.NewCacheWithParams(REACTION_CACHE_SIZE, "Reaction", REACTION_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_REACTIONS) localCacheStore.reaction = LocalCacheReactionStore{ReactionStore: baseStore.Reaction(), rootStore: &localCacheStore} - - // Roles localCacheStore.roleCache = cacheProvider.NewCacheWithParams(ROLE_CACHE_SIZE, "Role", ROLE_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_ROLES) localCacheStore.role = LocalCacheRoleStore{RoleStore: baseStore.Role(), rootStore: &localCacheStore} - - // Schemes localCacheStore.schemeCache = cacheProvider.NewCacheWithParams(SCHEME_CACHE_SIZE, "Scheme", SCHEME_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_SCHEMES) localCacheStore.scheme = LocalCacheSchemeStore{SchemeStore: baseStore.Scheme(), rootStore: &localCacheStore} - - // Webhooks localCacheStore.webhookCache = cacheProvider.NewCacheWithParams(WEBHOOK_CACHE_SIZE, "Webhook", WEBHOOK_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_WEBHOOKS) localCacheStore.webhook = LocalCacheWebhookStore{WebhookStore: baseStore.Webhook(), rootStore: &localCacheStore} - - // Emojis localCacheStore.emojiCacheById = cacheProvider.NewCacheWithParams(EMOJI_CACHE_SIZE, "EmojiById", EMOJI_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_BY_ID) localCacheStore.emojiIdCacheByName = cacheProvider.NewCacheWithParams(EMOJI_CACHE_SIZE, "EmojiByName", EMOJI_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_ID_BY_NAME) localCacheStore.emoji = LocalCacheEmojiStore{EmojiStore: baseStore.Emoji(), rootStore: &localCacheStore} - // Channels localCacheStore.channelPinnedPostCountsCache = cacheProvider.NewCacheWithParams(CHANNEL_PINNEDPOSTS_COUNTS_CACHE_SIZE, "ChannelPinnedPostsCounts", CHANNEL_PINNEDPOSTS_COUNTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_PINNEDPOSTS_COUNTS) localCacheStore.channelMemberCountsCache = cacheProvider.NewCacheWithParams(CHANNEL_MEMBERS_COUNTS_CACHE_SIZE, "ChannelMemberCounts", CHANNEL_MEMBERS_COUNTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBER_COUNTS) localCacheStore.channelGuestCountCache = cacheProvider.NewCacheWithParams(CHANNEL_GUEST_COUNT_CACHE_SIZE, "ChannelGuestsCount", CHANNEL_GUEST_COUNT_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_GUEST_COUNT) localCacheStore.channelByIdCache = cacheProvider.NewCacheWithParams(model.CHANNEL_CACHE_SIZE, "channelById", CHANNEL_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL) - localCacheStore.channelMembersForUserCache = cacheProvider.NewCacheWithParams(model.CHANNEL_CACHE_SIZE, "ChannelMembersForUser", CHANNEL_MEMBERS_FOR_USER_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBERS_FOR_USER) + localCacheStore.channel = LocalCacheChannelStore{ChannelStore: baseStore.Channel(), rootStore: &localCacheStore} - // Posts localCacheStore.postLastPostsCache = cacheProvider.NewCacheWithParams(LAST_POSTS_CACHE_SIZE, "LastPost", LAST_POSTS_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POSTS) localCacheStore.lastPostTimeCache = cacheProvider.NewCacheWithParams(LAST_POST_TIME_CACHE_SIZE, "LastPostTime", LAST_POST_TIME_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POST_TIME) + localCacheStore.post = LocalCachePostStore{PostStore: baseStore.Post(), rootStore: &localCacheStore} - // TOS localCacheStore.termsOfServiceCache = cacheProvider.NewCacheWithParams(TERMS_OF_SERVICE_CACHE_SIZE, "TermsOfService", TERMS_OF_SERVICE_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TERMS_OF_SERVICE) localCacheStore.termsOfService = LocalCacheTermsOfServiceStore{TermsOfServiceStore: baseStore.TermsOfService(), rootStore: &localCacheStore} - - // Users localCacheStore.userProfileByIdsCache = cacheProvider.NewCacheWithParams(USER_PROFILE_BY_ID_CACHE_SIZE, "UserProfileByIds", USER_PROFILE_BY_ID_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_PROFILE_BY_IDS) localCacheStore.profilesInChannelCache = cacheProvider.NewCacheWithParams(PROFILES_IN_CHANNEL_CACHE_SIZE, "ProfilesInChannel", PROFILES_IN_CHANNEL_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_PROFILE_IN_CHANNEL) localCacheStore.user = LocalCacheUserStore{UserStore: baseStore.User(), rootStore: &localCacheStore} - - // Teams localCacheStore.teamAllTeamIdsForUserCache = cacheProvider.NewCacheWithParams(TEAM_CACHE_SIZE, "Team", TEAM_CACHE_SEC, model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TEAMS) localCacheStore.team = LocalCacheTeamStore{TeamStore: baseStore.Team(), rootStore: &localCacheStore} if cluster != nil { cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_REACTIONS, localCacheStore.reaction.handleClusterInvalidateReaction) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_ROLES, localCacheStore.role.handleClusterInvalidateRole) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_SCHEMES, localCacheStore.scheme.handleClusterInvalidateScheme) - + cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POST_TIME, localCacheStore.post.handleClusterInvalidateLastPostTime) cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_WEBHOOKS, localCacheStore.webhook.handleClusterInvalidateWebhook) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_BY_ID, localCacheStore.emoji.handleClusterInvalidateEmojiById) cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_EMOJIS_ID_BY_NAME, localCacheStore.emoji.handleClusterInvalidateEmojiIdByName) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_PINNEDPOSTS_COUNTS, localCacheStore.channel.handleClusterInvalidateChannelPinnedPostCount) cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBER_COUNTS, localCacheStore.channel.handleClusterInvalidateChannelMemberCounts) cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_GUEST_COUNT, localCacheStore.channel.handleClusterInvalidateChannelGuestCounts) cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL, localCacheStore.channel.handleClusterInvalidateChannelById) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_CHANNEL_MEMBERS_FOR_USER, localCacheStore.channel.handleClusterInvalidateChannelMembersForUser) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POSTS, localCacheStore.post.handleClusterInvalidateLastPosts) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_LAST_POST_TIME, localCacheStore.post.handleClusterInvalidateLastPostTime) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TERMS_OF_SERVICE, localCacheStore.termsOfService.handleClusterInvalidateTermsOfService) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_PROFILE_BY_IDS, localCacheStore.user.handleClusterInvalidateScheme) cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_PROFILE_IN_CHANNEL, localCacheStore.user.handleClusterInvalidateProfilesInChannel) - cluster.RegisterClusterMessageHandler(model.CLUSTER_EVENT_INVALIDATE_CACHE_FOR_TEAMS, localCacheStore.team.handleClusterInvalidateTeam) } return localCacheStore @@ -283,7 +243,6 @@ func (s *LocalCacheStore) Invalidate() { s.doClearCacheCluster(s.emojiCacheById) s.doClearCacheCluster(s.emojiIdCacheByName) s.doClearCacheCluster(s.channelMemberCountsCache) - s.doClearCacheCluster(s.channelMembersForUserCache) s.doClearCacheCluster(s.channelPinnedPostCountsCache) s.doClearCacheCluster(s.channelGuestCountCache) s.doClearCacheCluster(s.channelByIdCache) diff --git a/store/localcachelayer/main_test.go b/store/localcachelayer/main_test.go index ac2deee2cc..35531668ff 100644 --- a/store/localcachelayer/main_test.go +++ b/store/localcachelayer/main_test.go @@ -80,12 +80,6 @@ func getMockCacheProvider() *mocks.CacheProvider { mock.AnythingOfType("int64"), mock.AnythingOfType("string")).Return(lru.New(128)) - mockCacheProvider.On("NewCacheWithParams", - mock.AnythingOfType("int"), - "ChannelMembersForUser", - mock.AnythingOfType("int64"), - mock.AnythingOfType("string")).Return(lru.New(128)) - mockCacheProvider.On("NewCacheWithParams", mock.AnythingOfType("int"), "LastPost", @@ -185,13 +179,6 @@ func getMockStore() *mocks.Store { mockPinnedPostsCount := int64(10) mockChannelStore.On("GetPinnedPostCount", "id", true).Return(mockPinnedPostsCount, nil) mockChannelStore.On("GetPinnedPostCount", "id", false).Return(mockPinnedPostsCount, nil) - fakeChannelMembers := model.ChannelMembers([]model.ChannelMember{ - { - UserId: "123", - }, - }) - mockChannelStore.On("GetMembersForUser", "teamId", "userId1").Return(&fakeChannelMembers, nil) - mockChannelStore.On("GetMembersForUser", "teamId", "userId2").Return(&fakeChannelMembers, nil) fakePosts := &model.PostList{} mockPostStore := mocks.PostStore{}