Mono repo -> Master (#22553)

Combines the following repositories into one:

https://github.com/mattermost/mattermost-server
https://github.com/mattermost/mattermost-webapp
https://github.com/mattermost/focalboard
https://github.com/mattermost/mattermost-plugin-playbooks

server/channels/store/localcachelayer/channel_layer.go

@@ -0,0 +1,264 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCacheChannelStore struct {
+	store.ChannelStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheChannelStore) handleClusterInvalidateChannelMemberCounts(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.channelMemberCountsCache.Purge()
+	} else {
+		s.rootStore.channelMemberCountsCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheChannelStore) handleClusterInvalidateChannelPinnedPostCount(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.channelPinnedPostCountsCache.Purge()
+	} else {
+		s.rootStore.channelPinnedPostCountsCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheChannelStore) handleClusterInvalidateChannelGuestCounts(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.channelGuestCountCache.Purge()
+	} else {
+		s.rootStore.channelGuestCountCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheChannelStore) handleClusterInvalidateChannelById(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.channelByIdCache.Purge()
+	} else {
+		s.rootStore.channelByIdCache.Remove(string(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.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")
+	}
+}
+
+func (s LocalCacheChannelStore) InvalidatePinnedPostCount(channelId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelPinnedPostCountsCache, channelId)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Pinned Post Counts - Remove by ChannelId")
+	}
+}
+
+func (s LocalCacheChannelStore) InvalidateMemberCount(channelId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelMemberCountsCache, channelId)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Member Counts - Remove by ChannelId")
+	}
+}
+
+func (s LocalCacheChannelStore) InvalidateGuestCount(channelId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelGuestCountCache, channelId)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel Guests Count - Remove by channelId")
+	}
+}
+
+func (s LocalCacheChannelStore) InvalidateChannel(channelId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.channelByIdCache, channelId)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Channel - Remove by ChannelId")
+	}
+}
+
+func (s LocalCacheChannelStore) GetMemberCount(channelId string, allowFromCache bool) (int64, error) {
+	if allowFromCache {
+		var count int64
+		if err := s.rootStore.doStandardReadCache(s.rootStore.channelMemberCountsCache, channelId, &count); err == nil {
+			return count, nil
+		}
+	}
+	count, err := s.ChannelStore.GetMemberCount(channelId, allowFromCache)
+
+	if allowFromCache && err == nil {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelMemberCountsCache, channelId, count)
+	}
+
+	return count, err
+}
+
+func (s LocalCacheChannelStore) GetGuestCount(channelId string, allowFromCache bool) (int64, error) {
+	if allowFromCache {
+		var count int64
+		if err := s.rootStore.doStandardReadCache(s.rootStore.channelGuestCountCache, channelId, &count); err == nil {
+			return count, nil
+		}
+	}
+	count, err := s.ChannelStore.GetGuestCount(channelId, allowFromCache)
+
+	if allowFromCache && err == nil {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelGuestCountCache, channelId, count)
+	}
+
+	return count, err
+}
+
+func (s LocalCacheChannelStore) GetMemberCountFromCache(channelId string) int64 {
+	var count int64
+	if err := s.rootStore.doStandardReadCache(s.rootStore.channelMemberCountsCache, channelId, &count); err == nil {
+		return count
+	}
+
+	count, err := s.GetMemberCount(channelId, true)
+	if err != nil {
+		return 0
+	}
+
+	return count
+}
+
+func (s LocalCacheChannelStore) GetPinnedPostCount(channelId string, allowFromCache bool) (int64, error) {
+	if allowFromCache {
+		var count int64
+		if err := s.rootStore.doStandardReadCache(s.rootStore.channelPinnedPostCountsCache, channelId, &count); err == nil {
+			return count, nil
+		}
+	}
+
+	count, err := s.ChannelStore.GetPinnedPostCount(channelId, allowFromCache)
+
+	if err != nil {
+		return 0, err
+	}
+
+	if allowFromCache {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelPinnedPostCountsCache, channelId, count)
+	}
+
+	return count, nil
+}
+
+func (s LocalCacheChannelStore) Get(id string, allowFromCache bool) (*model.Channel, error) {
+
+	if allowFromCache {
+		var cacheItem *model.Channel
+		if err := s.rootStore.doStandardReadCache(s.rootStore.channelByIdCache, id, &cacheItem); err == nil {
+			return cacheItem, nil
+		}
+	}
+
+	ch, err := s.ChannelStore.Get(id, allowFromCache)
+
+	if allowFromCache && err == nil {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelByIdCache, id, ch)
+	}
+
+	return ch, err
+}
+
+func (s LocalCacheChannelStore) GetMany(ids []string, allowFromCache bool) (model.ChannelList, error) {
+	var foundChannels []*model.Channel
+	var channelsToQuery []string
+
+	if allowFromCache {
+		for _, id := range ids {
+			var ch *model.Channel
+			if err := s.rootStore.doStandardReadCache(s.rootStore.channelByIdCache, id, &ch); err == nil {
+				foundChannels = append(foundChannels, ch)
+			} else {
+				channelsToQuery = append(channelsToQuery, id)
+			}
+		}
+	}
+
+	if channelsToQuery == nil {
+		return foundChannels, nil
+	}
+
+	channels, err := s.ChannelStore.GetMany(channelsToQuery, allowFromCache)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, ch := range channels {
+		s.rootStore.doStandardAddToCache(s.rootStore.channelByIdCache, ch.Id, ch)
+	}
+
+	return append(foundChannels, channels...), nil
+}
+
+func (s LocalCacheChannelStore) SaveMember(member *model.ChannelMember) (*model.ChannelMember, error) {
+	member, err := s.ChannelStore.SaveMember(member)
+	if err != nil {
+		return nil, err
+	}
+	s.InvalidateMemberCount(member.ChannelId)
+	return member, nil
+}
+
+func (s LocalCacheChannelStore) SaveMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
+	members, err := s.ChannelStore.SaveMultipleMembers(members)
+	if err != nil {
+		return nil, err
+	}
+	for _, member := range members {
+		s.InvalidateMemberCount(member.ChannelId)
+	}
+	return members, nil
+}
+
+func (s LocalCacheChannelStore) UpdateMember(member *model.ChannelMember) (*model.ChannelMember, error) {
+	member, err := s.ChannelStore.UpdateMember(member)
+	if err != nil {
+		return nil, err
+	}
+	s.InvalidateMemberCount(member.ChannelId)
+	return member, nil
+}
+
+func (s LocalCacheChannelStore) UpdateMultipleMembers(members []*model.ChannelMember) ([]*model.ChannelMember, error) {
+	members, err := s.ChannelStore.UpdateMultipleMembers(members)
+	if err != nil {
+		return nil, err
+	}
+	for _, member := range members {
+		s.InvalidateMemberCount(member.ChannelId)
+	}
+	return members, nil
+}
+
+func (s LocalCacheChannelStore) RemoveMember(channelId, userId string) error {
+	err := s.ChannelStore.RemoveMember(channelId, userId)
+	if err != nil {
+		return err
+	}
+	s.InvalidateMemberCount(channelId)
+	return nil
+}
+
+func (s LocalCacheChannelStore) RemoveMembers(channelId string, userIds []string) error {
+	err := s.ChannelStore.RemoveMembers(channelId, userIds)
+	if err != nil {
+		return err
+	}
+	s.InvalidateMemberCount(channelId)
+	return nil
+}

server/channels/store/localcachelayer/channel_layer_test.go

@@ -0,0 +1,319 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestChannelStore(t *testing.T) {
+	StoreTestWithSqlStore(t, storetest.TestReactionStore)
+}
+
+func TestChannelStoreChannelMemberCountsCache(t *testing.T) {
+	countResult := int64(10)
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		count, err := cachedStore.Channel().GetMemberCount("id", true)
+		require.NoError(t, err)
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+		count, err = cachedStore.Channel().GetMemberCount("id", true)
+		require.NoError(t, err)
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetMemberCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+		cachedStore.Channel().GetMemberCount("id", false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 2)
+	})
+
+	t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetMemberCount("id", false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+		cachedStore.Channel().GetMemberCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 2)
+		cachedStore.Channel().GetMemberCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 2)
+	})
+
+	t.Run("first call with GetMemberCountFromCache not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		count := cachedStore.Channel().GetMemberCountFromCache("id")
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+		count = cachedStore.Channel().GetMemberCountFromCache("id")
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+	})
+
+	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetMemberCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+		cachedStore.Channel().ClearCaches()
+		cachedStore.Channel().GetMemberCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 2)
+	})
+
+	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetMemberCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 1)
+		cachedStore.Channel().InvalidateMemberCount("id")
+		cachedStore.Channel().GetMemberCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetMemberCount", 2)
+	})
+}
+
+func TestChannelStoreChannelPinnedPostsCountsCache(t *testing.T) {
+	countResult := int64(10)
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		count, err := cachedStore.Channel().GetPinnedPostCount("id", true)
+		require.NoError(t, err)
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
+		count, err = cachedStore.Channel().GetPinnedPostCount("id", true)
+		require.NoError(t, err)
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetPinnedPostCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
+		cachedStore.Channel().GetPinnedPostCount("id", false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 2)
+	})
+
+	t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetPinnedPostCount("id", false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
+		cachedStore.Channel().GetPinnedPostCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 2)
+		cachedStore.Channel().GetPinnedPostCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 2)
+	})
+
+	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetPinnedPostCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
+		cachedStore.Channel().ClearCaches()
+		cachedStore.Channel().GetPinnedPostCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 2)
+	})
+
+	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetPinnedPostCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 1)
+		cachedStore.Channel().InvalidatePinnedPostCount("id")
+		cachedStore.Channel().GetPinnedPostCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetPinnedPostCount", 2)
+	})
+}
+
+func TestChannelStoreGuestCountCache(t *testing.T) {
+	countResult := int64(12)
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		count, err := cachedStore.Channel().GetGuestCount("id", true)
+		require.NoError(t, err)
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
+		count, err = cachedStore.Channel().GetGuestCount("id", true)
+		require.NoError(t, err)
+		assert.Equal(t, count, countResult)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetGuestCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
+		cachedStore.Channel().GetGuestCount("id", false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 2)
+	})
+
+	t.Run("first call force not cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetGuestCount("id", false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
+		cachedStore.Channel().GetGuestCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 2)
+		cachedStore.Channel().GetGuestCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 2)
+	})
+
+	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetGuestCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
+		cachedStore.Channel().ClearCaches()
+		cachedStore.Channel().GetGuestCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 2)
+	})
+
+	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().GetGuestCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 1)
+		cachedStore.Channel().InvalidateGuestCount("id")
+		cachedStore.Channel().GetGuestCount("id", true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "GetGuestCount", 2)
+	})
+}
+
+func TestChannelStoreChannel(t *testing.T) {
+	channelId := "channel1"
+	fakeChannel := model.Channel{Id: channelId}
+	t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		channel, err := cachedStore.Channel().Get(channelId, true)
+		require.NoError(t, err)
+		assert.Equal(t, channel, &fakeChannel)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
+		channel, err = cachedStore.Channel().Get(channelId, true)
+		require.NoError(t, err)
+		assert.Equal(t, channel, &fakeChannel)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
+	})
+
+	t.Run("first call not cached, second force no cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().Get(channelId, true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Channel().Get(channelId, false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call force no cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+		cachedStore.Channel().Get(channelId, false)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Channel().Get(channelId, true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 2)
+		cachedStore.Channel().Get(channelId, true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call not cached, clear cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Channel().Get(channelId, true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Channel().ClearCaches()
+		cachedStore.Channel().Get(channelId, true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call not cached, invalidate cache, second call not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+		cachedStore.Channel().Get(channelId, true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Channel().InvalidateChannel(channelId)
+		cachedStore.Channel().Get(channelId, true)
+		mockStore.Channel().(*mocks.ChannelStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+}

server/channels/store/localcachelayer/emoji_layer.go

@@ -0,0 +1,142 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+	"context"
+	"sync"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/sqlstore"
+)
+
+type LocalCacheEmojiStore struct {
+	store.EmojiStore
+	rootStore                *LocalCacheStore
+	emojiByIdMut             sync.Mutex
+	emojiByIdInvalidations   map[string]bool
+	emojiByNameMut           sync.Mutex
+	emojiByNameInvalidations map[string]bool
+}
+
+func (es *LocalCacheEmojiStore) handleClusterInvalidateEmojiById(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		es.rootStore.emojiCacheById.Purge()
+	} else {
+		es.emojiByIdMut.Lock()
+		es.emojiByIdInvalidations[string(msg.Data)] = true
+		es.emojiByIdMut.Unlock()
+		es.rootStore.emojiCacheById.Remove(string(msg.Data))
+	}
+}
+
+func (es *LocalCacheEmojiStore) handleClusterInvalidateEmojiIdByName(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		es.rootStore.emojiIdCacheByName.Purge()
+	} else {
+		es.emojiByNameMut.Lock()
+		es.emojiByNameInvalidations[string(msg.Data)] = true
+		es.emojiByNameMut.Unlock()
+		es.rootStore.emojiIdCacheByName.Remove(string(msg.Data))
+	}
+}
+
+func (es *LocalCacheEmojiStore) Get(ctx context.Context, id string, allowFromCache bool) (*model.Emoji, error) {
+	if allowFromCache {
+		if emoji, ok := es.getFromCacheById(id); ok {
+			return emoji, nil
+		}
+	}
+
+	// If it was invalidated, then we need to query master.
+	es.emojiByIdMut.Lock()
+	if es.emojiByIdInvalidations[id] {
+		// And then remove the key from the map.
+		ctx = sqlstore.WithMaster(ctx)
+		delete(es.emojiByIdInvalidations, id)
+	}
+	es.emojiByIdMut.Unlock()
+
+	emoji, err := es.EmojiStore.Get(ctx, id, allowFromCache)
+
+	if allowFromCache && err == nil {
+		es.addToCache(emoji)
+	}
+
+	return emoji, err
+}
+
+func (es *LocalCacheEmojiStore) GetByName(ctx context.Context, name string, allowFromCache bool) (*model.Emoji, error) {
+	if id, ok := model.GetSystemEmojiId(name); ok {
+		return es.Get(ctx, id, allowFromCache)
+	}
+
+	if allowFromCache {
+		if emoji, ok := es.getFromCacheByName(name); ok {
+			return emoji, nil
+		}
+	}
+
+	// If it was invalidated, then we need to query master.
+	es.emojiByNameMut.Lock()
+	if es.emojiByNameInvalidations[name] {
+		ctx = sqlstore.WithMaster(ctx)
+		// And then remove the key from the map.
+		delete(es.emojiByNameInvalidations, name)
+	}
+	es.emojiByNameMut.Unlock()
+
+	emoji, err := es.EmojiStore.GetByName(ctx, name, allowFromCache)
+
+	if allowFromCache && err == nil {
+		es.addToCache(emoji)
+	}
+
+	return emoji, err
+}
+
+func (es *LocalCacheEmojiStore) Delete(emoji *model.Emoji, time int64) error {
+	err := es.EmojiStore.Delete(emoji, time)
+
+	if err == nil {
+		es.removeFromCache(emoji)
+	}
+
+	return err
+}
+
+func (es *LocalCacheEmojiStore) addToCache(emoji *model.Emoji) {
+	es.rootStore.doStandardAddToCache(es.rootStore.emojiCacheById, emoji.Id, emoji)
+	es.rootStore.doStandardAddToCache(es.rootStore.emojiIdCacheByName, emoji.Name, emoji.Id)
+}
+
+func (es *LocalCacheEmojiStore) getFromCacheById(id string) (*model.Emoji, bool) {
+	var emoji *model.Emoji
+	if err := es.rootStore.doStandardReadCache(es.rootStore.emojiCacheById, id, &emoji); err == nil {
+		return emoji, true
+	}
+	return nil, false
+}
+
+func (es *LocalCacheEmojiStore) getFromCacheByName(name string) (*model.Emoji, bool) {
+	var emojiId string
+	if err := es.rootStore.doStandardReadCache(es.rootStore.emojiIdCacheByName, name, &emojiId); err == nil {
+		return es.getFromCacheById(emojiId)
+	}
+	return nil, false
+}
+
+func (es *LocalCacheEmojiStore) removeFromCache(emoji *model.Emoji) {
+	es.emojiByIdMut.Lock()
+	es.emojiByIdInvalidations[emoji.Id] = true
+	es.emojiByIdMut.Unlock()
+	es.rootStore.doInvalidateCacheCluster(es.rootStore.emojiCacheById, emoji.Id)
+
+	es.emojiByNameMut.Lock()
+	es.emojiByNameInvalidations[emoji.Name] = true
+	es.emojiByNameMut.Unlock()
+	es.rootStore.doInvalidateCacheCluster(es.rootStore.emojiIdCacheByName, emoji.Name)
+}

server/channels/store/localcachelayer/emoji_layer_test.go

@@ -0,0 +1,185 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestEmojiStore(t *testing.T) {
+	StoreTest(t, storetest.TestEmojiStore)
+}
+
+func TestEmojiStoreCache(t *testing.T) {
+	fakeEmoji := model.Emoji{Id: "123", Name: "name123"}
+	ctxEmoji := model.Emoji{Id: "master", Name: "name123"}
+
+	t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		emoji, err := cachedStore.Emoji().Get(context.Background(), "123", true)
+		require.NoError(t, err)
+		assert.Equal(t, emoji, &fakeEmoji)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
+		emoji, err = cachedStore.Emoji().Get(context.Background(), "123", true)
+		require.NoError(t, err)
+		assert.Equal(t, emoji, &fakeEmoji)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
+	})
+
+	t.Run("first call by name not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		emoji, err := cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		require.NoError(t, err)
+		assert.Equal(t, emoji, &fakeEmoji)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
+		emoji, err = cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		require.NoError(t, err)
+		assert.Equal(t, emoji, &fakeEmoji)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
+	})
+
+	t.Run("first call by id not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().Get(context.Background(), "123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Emoji().Get(context.Background(), "123", false)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call by name not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Emoji().GetByName(context.Background(), "name123", false)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
+	})
+
+	t.Run("first call by id force not cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().Get(context.Background(), "123", false)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Emoji().Get(context.Background(), "123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
+		cachedStore.Emoji().Get(context.Background(), "123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call by name force not cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().GetByName(context.Background(), "name123", false)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
+		cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
+	})
+
+	t.Run("first call by id, second call by name cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().Get(context.Background(), "123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 0)
+	})
+
+	t.Run("first call by name, second call by id cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Emoji().Get(context.Background(), "123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 0)
+	})
+
+	t.Run("first call by id not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().Get(context.Background(), "123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Emoji().Delete(&fakeEmoji, 0)
+		cachedStore.Emoji().Get(context.Background(), "123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("call by id, use master", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().Get(context.Background(), "master", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Emoji().Delete(&ctxEmoji, 0)
+		cachedStore.Emoji().Get(context.Background(), "master", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call by name not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Emoji().Delete(&fakeEmoji, 0)
+		cachedStore.Emoji().GetByName(context.Background(), "name123", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
+	})
+
+	t.Run("call by name, use master", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Emoji().GetByName(context.Background(), "master", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Emoji().Delete(&ctxEmoji, 0)
+		cachedStore.Emoji().GetByName(context.Background(), "master", true)
+		mockStore.Emoji().(*mocks.EmojiStore).AssertNumberOfCalls(t, "GetByName", 2)
+	})
+}

server/channels/store/localcachelayer/file_info_layer.go

@@ -0,0 +1,99 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCacheFileInfoStore struct {
+	store.FileInfoStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheFileInfoStore) handleClusterInvalidateFileInfo(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.fileInfoCache.Purge()
+		return
+	}
+	s.rootStore.fileInfoCache.Remove(string(msg.Data))
+}
+
+func (s LocalCacheFileInfoStore) GetForPost(postId string, readFromMaster, includeDeleted, allowFromCache bool) ([]*model.FileInfo, error) {
+	if !allowFromCache {
+		return s.FileInfoStore.GetForPost(postId, readFromMaster, includeDeleted, allowFromCache)
+	}
+
+	cacheKey := postId
+	if includeDeleted {
+		cacheKey += "_deleted"
+	}
+
+	var fileInfo []*model.FileInfo
+	if err := s.rootStore.doStandardReadCache(s.rootStore.fileInfoCache, cacheKey, &fileInfo); err == nil {
+		return fileInfo, nil
+	}
+
+	fileInfos, err := s.FileInfoStore.GetForPost(postId, readFromMaster, includeDeleted, allowFromCache)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(fileInfos) > 0 {
+		s.rootStore.doStandardAddToCache(s.rootStore.fileInfoCache, cacheKey, fileInfos)
+	}
+
+	return fileInfos, nil
+}
+
+func (s LocalCacheFileInfoStore) ClearCaches() {
+	s.rootStore.fileInfoCache.Purge()
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("File Info Cache - Purge")
+	}
+}
+
+func (s LocalCacheFileInfoStore) InvalidateFileInfosForPostCache(postId string, deleted bool) {
+	cacheKey := postId
+	if deleted {
+		cacheKey += "_deleted"
+	}
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.fileInfoCache, cacheKey)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("File Info Cache - Remove by PostId")
+	}
+}
+
+func (s LocalCacheFileInfoStore) GetStorageUsage(allowFromCache, includeDeleted bool) (int64, error) {
+	storageUsageKey := "storage_usage"
+	if includeDeleted {
+		storageUsageKey += "_deleted"
+	}
+
+	if !allowFromCache {
+		usage, err := s.FileInfoStore.GetStorageUsage(allowFromCache, includeDeleted)
+		if err != nil {
+			return 0, err
+		}
+
+		s.rootStore.doStandardAddToCache(s.rootStore.fileInfoCache, storageUsageKey, usage)
+		return usage, nil
+	}
+
+	var usage int64
+	if err := s.rootStore.doStandardReadCache(s.rootStore.fileInfoCache, storageUsageKey, &usage); err == nil {
+		return usage, nil
+	}
+
+	usage, err := s.FileInfoStore.GetStorageUsage(allowFromCache, includeDeleted)
+	if err != nil {
+		return 0, err
+	}
+
+	s.rootStore.doStandardAddToCache(s.rootStore.fileInfoCache, storageUsageKey, usage)
+	return usage, nil
+}

server/channels/store/localcachelayer/file_info_layer_test.go

@@ -0,0 +1,63 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestFileInfoStore(t *testing.T) {
+	StoreTestWithSqlStore(t, storetest.TestFileInfoStore)
+}
+
+func TestFileInfoStoreCache(t *testing.T) {
+	fakeFileInfo := model.FileInfo{PostId: "123"}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		fileInfos, err := cachedStore.FileInfo().GetForPost("123", true, true, true)
+		require.NoError(t, err)
+		assert.Equal(t, fileInfos, []*model.FileInfo{&fakeFileInfo})
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 1)
+		assert.Equal(t, fileInfos, []*model.FileInfo{&fakeFileInfo})
+		cachedStore.FileInfo().GetForPost("123", true, true, true)
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 1)
+	})
+
+	t.Run("first call not cached, second force no cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.FileInfo().GetForPost("123", true, true, true)
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 1)
+		cachedStore.FileInfo().GetForPost("123", true, true, false)
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 2)
+	})
+
+	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.FileInfo().GetForPost("123", true, true, true)
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 1)
+		cachedStore.FileInfo().InvalidateFileInfosForPostCache("123", true)
+		cachedStore.FileInfo().GetForPost("123", true, true, true)
+		mockStore.FileInfo().(*mocks.FileInfoStore).AssertNumberOfCalls(t, "GetForPost", 2)
+	})
+}

server/channels/store/localcachelayer/layer.go

@@ -0,0 +1,460 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"runtime"
+	"time"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/einterfaces"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/platform/services/cache"
+)
+
+const (
+	ReactionCacheSize = 20000
+	ReactionCacheSec  = 30 * 60
+
+	RoleCacheSize = 20000
+	RoleCacheSec  = 30 * 60
+
+	SchemeCacheSize = 20000
+	SchemeCacheSec  = 30 * 60
+
+	FileInfoCacheSize = 25000
+	FileInfoCacheSec  = 30 * 60
+
+	ChannelGuestCountCacheSize = model.ChannelCacheSize
+	ChannelGuestCountCacheSec  = 30 * 60
+
+	WebhookCacheSize = 25000
+	WebhookCacheSec  = 15 * 60
+
+	EmojiCacheSize = 5000
+	EmojiCacheSec  = 30 * 60
+
+	ChannelPinnedPostsCountsCacheSize = model.ChannelCacheSize
+	ChannelPinnedPostsCountsCacheSec  = 30 * 60
+
+	ChannelMembersCountsCacheSize = model.ChannelCacheSize
+	ChannelMembersCountsCacheSec  = 30 * 60
+
+	LastPostsCacheSize  = 20000
+	LastPostsCacheSec   = 30 * 60
+	PostsUsageCacheSize = 1
+	PostsUsageCacheSec  = 30 * 60
+
+	TermsOfServiceCacheSize = 20000
+	TermsOfServiceCacheSec  = 30 * 60
+	LastPostTimeCacheSize   = 25000
+	LastPostTimeCacheSec    = 15 * 60
+
+	UserProfileByIDCacheSize = 20000
+	UserProfileByIDSec       = 30 * 60
+
+	ProfilesInChannelCacheSize = model.ChannelCacheSize
+	ProfilesInChannelCacheSec  = 15 * 60
+
+	TeamCacheSize = 20000
+	TeamCacheSec  = 30 * 60
+
+	ChannelCacheSec = 15 * 60 // 15 mins
+)
+
+var clearCacheMessageData = []byte("")
+
+type LocalCacheStore struct {
+	store.Store
+	metrics einterfaces.MetricsInterface
+	cluster einterfaces.ClusterInterface
+
+	reaction      LocalCacheReactionStore
+	reactionCache cache.Cache
+
+	fileInfo      LocalCacheFileInfoStore
+	fileInfoCache cache.Cache
+
+	role                 LocalCacheRoleStore
+	roleCache            cache.Cache
+	rolePermissionsCache 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
+
+	webhook      LocalCacheWebhookStore
+	webhookCache cache.Cache
+
+	post               LocalCachePostStore
+	postLastPostsCache cache.Cache
+	lastPostTimeCache  cache.Cache
+	postsUsageCache    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 LocalCacheStore, err error) {
+	localCacheStore = LocalCacheStore{
+		Store:   baseStore,
+		cluster: cluster,
+		metrics: metrics,
+	}
+	// Reactions
+	if localCacheStore.reactionCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   ReactionCacheSize,
+		Name:                   "Reaction",
+		DefaultExpiry:          ReactionCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForReactions,
+	}); err != nil {
+		return
+	}
+	localCacheStore.reaction = LocalCacheReactionStore{ReactionStore: baseStore.Reaction(), rootStore: &localCacheStore}
+
+	// Roles
+	if localCacheStore.roleCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   RoleCacheSize,
+		Name:                   "Role",
+		DefaultExpiry:          RoleCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForRoles,
+		Striped:                true,
+		StripedBuckets:         maxInt(runtime.NumCPU()-1, 1),
+	}); err != nil {
+		return
+	}
+	if localCacheStore.rolePermissionsCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   RoleCacheSize,
+		Name:                   "RolePermission",
+		DefaultExpiry:          RoleCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForRolePermissions,
+	}); err != nil {
+		return
+	}
+	localCacheStore.role = LocalCacheRoleStore{RoleStore: baseStore.Role(), rootStore: &localCacheStore}
+
+	// Schemes
+	if localCacheStore.schemeCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   SchemeCacheSize,
+		Name:                   "Scheme",
+		DefaultExpiry:          SchemeCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForSchemes,
+	}); err != nil {
+		return
+	}
+	localCacheStore.scheme = LocalCacheSchemeStore{SchemeStore: baseStore.Scheme(), rootStore: &localCacheStore}
+
+	// FileInfo
+	if localCacheStore.fileInfoCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   FileInfoCacheSize,
+		Name:                   "FileInfo",
+		DefaultExpiry:          FileInfoCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForFileInfos,
+	}); err != nil {
+		return
+	}
+	localCacheStore.fileInfo = LocalCacheFileInfoStore{FileInfoStore: baseStore.FileInfo(), rootStore: &localCacheStore}
+
+	// Webhooks
+	if localCacheStore.webhookCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   WebhookCacheSize,
+		Name:                   "Webhook",
+		DefaultExpiry:          WebhookCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForWebhooks,
+	}); err != nil {
+		return
+	}
+	localCacheStore.webhook = LocalCacheWebhookStore{WebhookStore: baseStore.Webhook(), rootStore: &localCacheStore}
+
+	// Emojis
+	if localCacheStore.emojiCacheById, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   EmojiCacheSize,
+		Name:                   "EmojiById",
+		DefaultExpiry:          EmojiCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForEmojisById,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.emojiIdCacheByName, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   EmojiCacheSize,
+		Name:                   "EmojiByName",
+		DefaultExpiry:          EmojiCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForEmojisIdByName,
+	}); err != nil {
+		return
+	}
+	localCacheStore.emoji = &LocalCacheEmojiStore{
+		EmojiStore:               baseStore.Emoji(),
+		rootStore:                &localCacheStore,
+		emojiByIdInvalidations:   make(map[string]bool),
+		emojiByNameInvalidations: make(map[string]bool),
+	}
+
+	// Channels
+	if localCacheStore.channelPinnedPostCountsCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   ChannelPinnedPostsCountsCacheSize,
+		Name:                   "ChannelPinnedPostsCounts",
+		DefaultExpiry:          ChannelPinnedPostsCountsCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForChannelPinnedpostsCounts,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.channelMemberCountsCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   ChannelMembersCountsCacheSize,
+		Name:                   "ChannelMemberCounts",
+		DefaultExpiry:          ChannelMembersCountsCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForChannelMemberCounts,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.channelGuestCountCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   ChannelGuestCountCacheSize,
+		Name:                   "ChannelGuestsCount",
+		DefaultExpiry:          ChannelGuestCountCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForChannelGuestCount,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.channelByIdCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   model.ChannelCacheSize,
+		Name:                   "channelById",
+		DefaultExpiry:          ChannelCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForChannel,
+	}); err != nil {
+		return
+	}
+	localCacheStore.channel = LocalCacheChannelStore{ChannelStore: baseStore.Channel(), rootStore: &localCacheStore}
+
+	// Posts
+	if localCacheStore.postLastPostsCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   LastPostsCacheSize,
+		Name:                   "LastPost",
+		DefaultExpiry:          LastPostsCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForLastPosts,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.lastPostTimeCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   LastPostTimeCacheSize,
+		Name:                   "LastPostTime",
+		DefaultExpiry:          LastPostTimeCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForLastPostTime,
+	}); err != nil {
+		return
+	}
+	if localCacheStore.postsUsageCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   PostsUsageCacheSize,
+		Name:                   "PostsUsage",
+		DefaultExpiry:          PostsUsageCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForPostsUsage,
+	}); err != nil {
+		return
+	}
+	localCacheStore.post = LocalCachePostStore{PostStore: baseStore.Post(), rootStore: &localCacheStore}
+
+	// TOS
+	if localCacheStore.termsOfServiceCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   TermsOfServiceCacheSize,
+		Name:                   "TermsOfService",
+		DefaultExpiry:          TermsOfServiceCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForTermsOfService,
+	}); err != nil {
+		return
+	}
+	localCacheStore.termsOfService = LocalCacheTermsOfServiceStore{TermsOfServiceStore: baseStore.TermsOfService(), rootStore: &localCacheStore}
+
+	// Users
+	if localCacheStore.userProfileByIdsCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   UserProfileByIDCacheSize,
+		Name:                   "UserProfileByIds",
+		DefaultExpiry:          UserProfileByIDSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForProfileByIds,
+		Striped:                true,
+		StripedBuckets:         maxInt(runtime.NumCPU()-1, 1),
+	}); err != nil {
+		return
+	}
+	if localCacheStore.profilesInChannelCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   ProfilesInChannelCacheSize,
+		Name:                   "ProfilesInChannel",
+		DefaultExpiry:          ProfilesInChannelCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForProfileInChannel,
+	}); err != nil {
+		return
+	}
+	localCacheStore.user = &LocalCacheUserStore{
+		UserStore:                     baseStore.User(),
+		rootStore:                     &localCacheStore,
+		userProfileByIdsInvalidations: make(map[string]bool),
+	}
+
+	// Teams
+	if localCacheStore.teamAllTeamIdsForUserCache, err = cacheProvider.NewCache(&cache.CacheOptions{
+		Size:                   TeamCacheSize,
+		Name:                   "Team",
+		DefaultExpiry:          TeamCacheSec * time.Second,
+		InvalidateClusterEvent: model.ClusterEventInvalidateCacheForTeams,
+	}); err != nil {
+		return
+	}
+	localCacheStore.team = LocalCacheTeamStore{TeamStore: baseStore.Team(), rootStore: &localCacheStore}
+
+	if cluster != nil {
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForReactions, localCacheStore.reaction.handleClusterInvalidateReaction)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForRoles, localCacheStore.role.handleClusterInvalidateRole)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForRolePermissions, localCacheStore.role.handleClusterInvalidateRolePermissions)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForSchemes, localCacheStore.scheme.handleClusterInvalidateScheme)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForFileInfos, localCacheStore.fileInfo.handleClusterInvalidateFileInfo)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForLastPostTime, localCacheStore.post.handleClusterInvalidateLastPostTime)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForPostsUsage, localCacheStore.post.handleClusterInvalidatePostsUsage)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForWebhooks, localCacheStore.webhook.handleClusterInvalidateWebhook)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForEmojisById, localCacheStore.emoji.handleClusterInvalidateEmojiById)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForEmojisIdByName, localCacheStore.emoji.handleClusterInvalidateEmojiIdByName)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannelPinnedpostsCounts, localCacheStore.channel.handleClusterInvalidateChannelPinnedPostCount)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannelMemberCounts, localCacheStore.channel.handleClusterInvalidateChannelMemberCounts)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannelGuestCount, localCacheStore.channel.handleClusterInvalidateChannelGuestCounts)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForChannel, localCacheStore.channel.handleClusterInvalidateChannelById)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForLastPosts, localCacheStore.post.handleClusterInvalidateLastPosts)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForTermsOfService, localCacheStore.termsOfService.handleClusterInvalidateTermsOfService)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForProfileByIds, localCacheStore.user.handleClusterInvalidateScheme)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForProfileInChannel, localCacheStore.user.handleClusterInvalidateProfilesInChannel)
+		cluster.RegisterClusterMessageHandler(model.ClusterEventInvalidateCacheForTeams, localCacheStore.team.handleClusterInvalidateTeam)
+	}
+	return
+}
+
+func maxInt(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func (s LocalCacheStore) Reaction() store.ReactionStore {
+	return s.reaction
+}
+
+func (s LocalCacheStore) Role() store.RoleStore {
+	return s.role
+}
+
+func (s LocalCacheStore) Scheme() store.SchemeStore {
+	return s.scheme
+}
+
+func (s LocalCacheStore) FileInfo() store.FileInfoStore {
+	return s.fileInfo
+}
+
+func (s LocalCacheStore) Webhook() store.WebhookStore {
+	return s.webhook
+}
+
+func (s LocalCacheStore) Emoji() store.EmojiStore {
+	return s.emoji
+}
+
+func (s LocalCacheStore) Channel() store.ChannelStore {
+	return s.channel
+}
+
+func (s LocalCacheStore) Post() store.PostStore {
+	return s.post
+}
+
+func (s LocalCacheStore) TermsOfService() store.TermsOfServiceStore {
+	return s.termsOfService
+}
+
+func (s LocalCacheStore) User() store.UserStore {
+	return s.user
+}
+
+func (s LocalCacheStore) Team() store.TeamStore {
+	return s.team
+}
+
+func (s LocalCacheStore) DropAllTables() {
+	s.Invalidate()
+	s.Store.DropAllTables()
+}
+
+func (s *LocalCacheStore) doInvalidateCacheCluster(cache cache.Cache, key string) {
+	cache.Remove(key)
+	if s.cluster != nil {
+		msg := &model.ClusterMessage{
+			Event:    cache.GetInvalidateClusterEvent(),
+			SendType: model.ClusterSendBestEffort,
+			Data:     []byte(key),
+		}
+		s.cluster.SendClusterMessage(msg)
+	}
+}
+
+func (s *LocalCacheStore) doStandardAddToCache(cache cache.Cache, key string, value any) {
+	cache.SetWithDefaultExpiry(key, value)
+}
+
+func (s *LocalCacheStore) doStandardReadCache(cache cache.Cache, key string, value any) error {
+	err := cache.Get(key, value)
+	if err == nil {
+		if s.metrics != nil {
+			s.metrics.IncrementMemCacheHitCounter(cache.Name())
+		}
+		return nil
+	}
+	if s.metrics != nil {
+		s.metrics.IncrementMemCacheMissCounter(cache.Name())
+	}
+	return err
+}
+
+func (s *LocalCacheStore) doClearCacheCluster(cache cache.Cache) {
+	cache.Purge()
+	if s.cluster != nil {
+		msg := &model.ClusterMessage{
+			Event:    cache.GetInvalidateClusterEvent(),
+			SendType: model.ClusterSendBestEffort,
+			Data:     clearCacheMessageData,
+		}
+		s.cluster.SendClusterMessage(msg)
+	}
+}
+
+func (s *LocalCacheStore) Invalidate() {
+	s.doClearCacheCluster(s.reactionCache)
+	s.doClearCacheCluster(s.schemeCache)
+	s.doClearCacheCluster(s.roleCache)
+	s.doClearCacheCluster(s.fileInfoCache)
+	s.doClearCacheCluster(s.webhookCache)
+	s.doClearCacheCluster(s.emojiCacheById)
+	s.doClearCacheCluster(s.emojiIdCacheByName)
+	s.doClearCacheCluster(s.channelMemberCountsCache)
+	s.doClearCacheCluster(s.channelPinnedPostCountsCache)
+	s.doClearCacheCluster(s.channelGuestCountCache)
+	s.doClearCacheCluster(s.channelByIdCache)
+	s.doClearCacheCluster(s.postLastPostsCache)
+	s.doClearCacheCluster(s.termsOfServiceCache)
+	s.doClearCacheCluster(s.lastPostTimeCache)
+	s.doClearCacheCluster(s.userProfileByIdsCache)
+	s.doClearCacheCluster(s.profilesInChannelCache)
+	s.doClearCacheCluster(s.teamAllTeamIdsForUserCache)
+	s.doClearCacheCluster(s.rolePermissionsCache)
+}

server/channels/store/localcachelayer/layer_test.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"os"
+	"sync"
+	"testing"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/sqlstore"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+)
+
+type storeType struct {
+	Name        string
+	SqlSettings *model.SqlSettings
+	SqlStore    *sqlstore.SqlStore
+	Store       store.Store
+}
+
+var storeTypes []*storeType
+
+func newStoreType(name, driver string) *storeType {
+	return &storeType{
+		Name:        name,
+		SqlSettings: storetest.MakeSqlSettings(driver, false),
+	}
+}
+
+func StoreTest(t *testing.T, f func(*testing.T, store.Store)) {
+	defer func() {
+		if err := recover(); err != nil {
+			tearDownStores()
+			panic(err)
+		}
+	}()
+	for _, st := range storeTypes {
+		st := st
+		t.Run(st.Name, func(t *testing.T) {
+			if testing.Short() {
+				t.SkipNow()
+			}
+			f(t, st.Store)
+		})
+	}
+}
+
+func StoreTestWithSqlStore(t *testing.T, f func(*testing.T, store.Store, storetest.SqlStore)) {
+	defer func() {
+		if err := recover(); err != nil {
+			tearDownStores()
+			panic(err)
+		}
+	}()
+	for _, st := range storeTypes {
+		st := st
+		t.Run(st.Name, func(t *testing.T) {
+			if testing.Short() {
+				t.SkipNow()
+			}
+			f(t, st.Store, sqlstore.NewStoreTestWrapper(st.SqlStore))
+		})
+	}
+}
+
+func initStores() {
+	if testing.Short() {
+		return
+	}
+
+	// In CI, we already run the entire test suite for both mysql and postgres in parallel.
+	// So we just run the tests for the current database set.
+	if os.Getenv("IS_CI") == "true" {
+		switch os.Getenv("MM_SQLSETTINGS_DRIVERNAME") {
+		case "mysql":
+			storeTypes = append(storeTypes, newStoreType("LocalCache+MySQL", model.DatabaseDriverMysql))
+		case "postgres":
+			storeTypes = append(storeTypes, newStoreType("LocalCache+PostgreSQL", model.DatabaseDriverPostgres))
+		}
+	} else {
+		storeTypes = append(storeTypes, newStoreType("LocalCache+MySQL", model.DatabaseDriverMysql),
+			newStoreType("LocalCache+PostgreSQL", model.DatabaseDriverPostgres))
+	}
+
+	defer func() {
+		if err := recover(); err != nil {
+			tearDownStores()
+			panic(err)
+		}
+	}()
+	var wg sync.WaitGroup
+	for _, st := range storeTypes {
+		st := st
+		wg.Add(1)
+		go func() {
+			var err error
+			defer wg.Done()
+			st.SqlStore = sqlstore.New(*st.SqlSettings, nil)
+			st.Store, err = NewLocalCacheLayer(st.SqlStore, nil, nil, getMockCacheProvider())
+			if err != nil {
+				panic(err)
+			}
+			st.Store.DropAllTables()
+			st.Store.MarkSystemRanUnitTests()
+		}()
+	}
+	wg.Wait()
+}
+
+var tearDownStoresOnce sync.Once
+
+func tearDownStores() {
+	if testing.Short() {
+		return
+	}
+	tearDownStoresOnce.Do(func() {
+		var wg sync.WaitGroup
+		wg.Add(len(storeTypes))
+		for _, st := range storeTypes {
+			st := st
+			go func() {
+				if st.Store != nil {
+					st.Store.Close()
+				}
+				if st.SqlSettings != nil {
+					storetest.CleanupSqlSettings(st.SqlSettings)
+				}
+				wg.Done()
+			}()
+		}
+		wg.Wait()
+	})
+}

server/channels/store/localcachelayer/main_test.go

@@ -0,0 +1,180 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/sqlstore"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+	"github.com/mattermost/mattermost-server/v6/server/channels/testlib"
+	"github.com/mattermost/mattermost-server/v6/server/platform/services/cache"
+	cachemocks "github.com/mattermost/mattermost-server/v6/server/platform/services/cache/mocks"
+)
+
+var mainHelper *testlib.MainHelper
+
+func getMockCacheProvider() cache.Provider {
+	mockCacheProvider := cachemocks.Provider{}
+	mockCacheProvider.On("NewCache", mock.Anything).
+		Return(cache.NewLRU(cache.LRUOptions{Size: 128}), nil)
+	return &mockCacheProvider
+}
+
+func getMockStore() *mocks.Store {
+	mockStore := mocks.Store{}
+
+	fakeReaction := model.Reaction{PostId: "123"}
+	mockReactionsStore := mocks.ReactionStore{}
+	mockReactionsStore.On("Save", &fakeReaction).Return(&model.Reaction{}, nil)
+	mockReactionsStore.On("Delete", &fakeReaction).Return(&model.Reaction{}, nil)
+	mockReactionsStore.On("GetForPost", "123", false).Return([]*model.Reaction{&fakeReaction}, nil)
+	mockReactionsStore.On("GetForPost", "123", true).Return([]*model.Reaction{&fakeReaction}, nil)
+	mockStore.On("Reaction").Return(&mockReactionsStore)
+
+	fakeRole := model.Role{Id: "123", Name: "role-name"}
+	mockRolesStore := mocks.RoleStore{}
+	mockRolesStore.On("Save", &fakeRole).Return(&model.Role{}, nil)
+	mockRolesStore.On("Delete", "123").Return(&fakeRole, nil)
+	mockRolesStore.On("GetByName", context.Background(), "role-name").Return(&fakeRole, nil)
+	mockRolesStore.On("GetByNames", []string{"role-name"}).Return([]*model.Role{&fakeRole}, nil)
+	mockRolesStore.On("PermanentDeleteAll").Return(nil)
+	mockStore.On("Role").Return(&mockRolesStore)
+
+	fakeScheme := model.Scheme{Id: "123", Name: "scheme-name"}
+	mockSchemesStore := mocks.SchemeStore{}
+	mockSchemesStore.On("Save", &fakeScheme).Return(&model.Scheme{}, nil)
+	mockSchemesStore.On("Delete", "123").Return(&model.Scheme{}, nil)
+	mockSchemesStore.On("Get", "123").Return(&fakeScheme, nil)
+	mockSchemesStore.On("PermanentDeleteAll").Return(nil)
+	mockStore.On("Scheme").Return(&mockSchemesStore)
+
+	fakeFileInfo := model.FileInfo{PostId: "123"}
+	mockFileInfoStore := mocks.FileInfoStore{}
+	mockFileInfoStore.On("GetForPost", "123", true, true, false).Return([]*model.FileInfo{&fakeFileInfo}, nil)
+	mockFileInfoStore.On("GetForPost", "123", true, true, true).Return([]*model.FileInfo{&fakeFileInfo}, nil)
+	mockStore.On("FileInfo").Return(&mockFileInfoStore)
+
+	fakeWebhook := model.IncomingWebhook{Id: "123"}
+	mockWebhookStore := mocks.WebhookStore{}
+	mockWebhookStore.On("GetIncoming", "123", true).Return(&fakeWebhook, nil)
+	mockWebhookStore.On("GetIncoming", "123", false).Return(&fakeWebhook, nil)
+	mockStore.On("Webhook").Return(&mockWebhookStore)
+
+	fakeEmoji := model.Emoji{Id: "123", Name: "name123"}
+	ctxEmoji := model.Emoji{Id: "master", Name: "name123"}
+	mockEmojiStore := mocks.EmojiStore{}
+	mockEmojiStore.On("Get", mock.Anything, "123", true).Return(&fakeEmoji, nil)
+	mockEmojiStore.On("Get", mock.Anything, "123", false).Return(&fakeEmoji, nil)
+	mockEmojiStore.On("Get", context.Background(), "master", true).Return(&ctxEmoji, nil)
+	mockEmojiStore.On("Get", sqlstore.WithMaster(context.Background()), "master", true).Return(&ctxEmoji, nil)
+	mockEmojiStore.On("GetByName", mock.Anything, "name123", true).Return(&fakeEmoji, nil)
+	mockEmojiStore.On("GetByName", mock.Anything, "name123", false).Return(&fakeEmoji, nil)
+	mockEmojiStore.On("GetByName", context.Background(), "master", true).Return(&ctxEmoji, nil)
+	mockEmojiStore.On("GetByName", sqlstore.WithMaster(context.Background()), "master", false).Return(&ctxEmoji, nil)
+	mockEmojiStore.On("Delete", &fakeEmoji, int64(0)).Return(nil)
+	mockEmojiStore.On("Delete", &ctxEmoji, int64(0)).Return(nil)
+	mockStore.On("Emoji").Return(&mockEmojiStore)
+
+	mockCount := int64(10)
+	mockGuestCount := int64(12)
+	channelId := "channel1"
+	fakeChannelId := model.Channel{Id: channelId}
+	mockChannelStore := mocks.ChannelStore{}
+	mockChannelStore.On("ClearCaches").Return()
+	mockChannelStore.On("GetMemberCount", "id", true).Return(mockCount, nil)
+	mockChannelStore.On("GetMemberCount", "id", false).Return(mockCount, nil)
+	mockChannelStore.On("GetGuestCount", "id", true).Return(mockGuestCount, nil)
+	mockChannelStore.On("GetGuestCount", "id", false).Return(mockGuestCount, nil)
+	mockChannelStore.On("Get", channelId, true).Return(&fakeChannelId, nil)
+	mockChannelStore.On("Get", channelId, false).Return(&fakeChannelId, nil)
+	mockStore.On("Channel").Return(&mockChannelStore)
+
+	mockPinnedPostsCount := int64(10)
+	mockChannelStore.On("GetPinnedPostCount", "id", true).Return(mockPinnedPostsCount, nil)
+	mockChannelStore.On("GetPinnedPostCount", "id", false).Return(mockPinnedPostsCount, nil)
+
+	fakePosts := &model.PostList{}
+	fakeOptions := model.GetPostsOptions{ChannelId: "123", PerPage: 30}
+	mockPostStore := mocks.PostStore{}
+	mockPostStore.On("GetPosts", fakeOptions, true, map[string]bool{}).Return(fakePosts, nil)
+	mockPostStore.On("GetPosts", fakeOptions, false, map[string]bool{}).Return(fakePosts, nil)
+	mockPostStore.On("InvalidateLastPostTimeCache", "12360")
+
+	mockPostStoreOptions := model.GetPostsSinceOptions{
+		ChannelId:        "channelId",
+		Time:             1,
+		SkipFetchThreads: false,
+	}
+
+	mockPostStoreEtagResult := fmt.Sprintf("%v.%v", model.CurrentVersion, 1)
+	mockPostStore.On("ClearCaches")
+	mockPostStore.On("InvalidateLastPostTimeCache", "channelId")
+	mockPostStore.On("GetEtag", "channelId", true, false).Return(mockPostStoreEtagResult)
+	mockPostStore.On("GetEtag", "channelId", false, false).Return(mockPostStoreEtagResult)
+	mockPostStore.On("GetPostsSince", mockPostStoreOptions, true, map[string]bool{}).Return(model.NewPostList(), nil)
+	mockPostStore.On("GetPostsSince", mockPostStoreOptions, false, map[string]bool{}).Return(model.NewPostList(), nil)
+	mockStore.On("Post").Return(&mockPostStore)
+
+	fakeTermsOfService := model.TermsOfService{Id: "123", CreateAt: 11111, UserId: "321", Text: "Terms of service test"}
+	mockTermsOfServiceStore := mocks.TermsOfServiceStore{}
+	mockTermsOfServiceStore.On("InvalidateTermsOfService", "123")
+	mockTermsOfServiceStore.On("Save", &fakeTermsOfService).Return(&fakeTermsOfService, nil)
+	mockTermsOfServiceStore.On("GetLatest", true).Return(&fakeTermsOfService, nil)
+	mockTermsOfServiceStore.On("GetLatest", false).Return(&fakeTermsOfService, nil)
+	mockTermsOfServiceStore.On("Get", "123", true).Return(&fakeTermsOfService, nil)
+	mockTermsOfServiceStore.On("Get", "123", false).Return(&fakeTermsOfService, nil)
+	mockStore.On("TermsOfService").Return(&mockTermsOfServiceStore)
+
+	fakeUser := []*model.User{{
+		Id:          "123",
+		AuthData:    model.NewString("authData"),
+		AuthService: "authService",
+	}}
+	mockUserStore := mocks.UserStore{}
+	mockUserStore.On("GetProfileByIds", mock.Anything, []string{"123"}, &store.UserGetByIdsOpts{}, true).Return(fakeUser, nil)
+	mockUserStore.On("GetProfileByIds", mock.Anything, []string{"123"}, &store.UserGetByIdsOpts{}, false).Return(fakeUser, nil)
+
+	fakeProfilesInChannelMap := map[string]*model.User{
+		"456": {Id: "456"},
+	}
+	mockUserStore.On("GetAllProfilesInChannel", mock.Anything, "123", true).Return(fakeProfilesInChannelMap, nil)
+	mockUserStore.On("GetAllProfilesInChannel", mock.Anything, "123", false).Return(fakeProfilesInChannelMap, nil)
+
+	mockUserStore.On("Get", mock.Anything, "123").Return(fakeUser[0], nil)
+	users := []*model.User{
+		fakeUser[0],
+		{
+			Id:          "456",
+			AuthData:    model.NewString("authData"),
+			AuthService: "authService",
+		},
+	}
+	mockUserStore.On("GetMany", mock.Anything, []string{"123", "456"}).Return(users, nil)
+	mockUserStore.On("GetMany", mock.Anything, []string{"123"}).Return(users[0:1], nil)
+	mockStore.On("User").Return(&mockUserStore)
+
+	fakeUserTeamIds := []string{"1", "2", "3"}
+	mockTeamStore := mocks.TeamStore{}
+	mockTeamStore.On("GetUserTeamIds", "123", true).Return(fakeUserTeamIds, nil)
+	mockTeamStore.On("GetUserTeamIds", "123", false).Return(fakeUserTeamIds, nil)
+	mockStore.On("Team").Return(&mockTeamStore)
+
+	return &mockStore
+}
+
+func TestMain(m *testing.M) {
+	mainHelper = testlib.NewMainHelperWithOptions(nil)
+	defer mainHelper.Close()
+
+	initStores()
+	mainHelper.Main(m)
+	tearDownStores()
+}

server/channels/store/localcachelayer/post_layer.go

@@ -0,0 +1,166 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCachePostStore struct {
+	store.PostStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCachePostStore) handleClusterInvalidateLastPostTime(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.lastPostTimeCache.Purge()
+	} else {
+		s.rootStore.lastPostTimeCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCachePostStore) handleClusterInvalidateLastPosts(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.postLastPostsCache.Purge()
+	} else {
+		s.rootStore.postLastPostsCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCachePostStore) handleClusterInvalidatePostsUsage(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.postsUsageCache.Purge()
+	} else {
+		s.rootStore.postsUsageCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCachePostStore) ClearCaches() {
+	s.rootStore.doClearCacheCluster(s.rootStore.lastPostTimeCache)
+	s.rootStore.doClearCacheCluster(s.rootStore.postLastPostsCache)
+	s.rootStore.doClearCacheCluster(s.rootStore.postsUsageCache)
+	s.PostStore.ClearCaches()
+
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Last Post Time - Purge")
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Last Posts Cache - Purge")
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Posts Usage Cache - Purge")
+	}
+}
+
+func (s LocalCachePostStore) InvalidateLastPostTimeCache(channelId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.lastPostTimeCache, channelId)
+
+	// Keys are "{channelid}{limit}" and caching only occurs on limits of 30 and 60
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.postLastPostsCache, channelId+"30")
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.postLastPostsCache, channelId+"60")
+
+	s.PostStore.InvalidateLastPostTimeCache(channelId)
+
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Last Post Time - Remove by Channel Id")
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Last Posts Cache - Remove by Channel Id")
+	}
+}
+
+func (s LocalCachePostStore) GetEtag(channelId string, allowFromCache, collapsedThreads bool) string {
+	if allowFromCache {
+		var lastTime int64
+		if err := s.rootStore.doStandardReadCache(s.rootStore.lastPostTimeCache, channelId, &lastTime); err == nil {
+			return fmt.Sprintf("%v.%v", model.CurrentVersion, lastTime)
+		}
+	}
+
+	result := s.PostStore.GetEtag(channelId, allowFromCache, collapsedThreads)
+
+	splittedResult := strings.Split(result, ".")
+
+	lastTime, _ := strconv.ParseInt((splittedResult[len(splittedResult)-1]), 10, 64)
+
+	s.rootStore.doStandardAddToCache(s.rootStore.lastPostTimeCache, channelId, lastTime)
+
+	return result
+}
+
+func (s LocalCachePostStore) GetPostsSince(options model.GetPostsSinceOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
+	if allowFromCache {
+		// If the last post in the channel's time is less than or equal to the time we are getting posts since,
+		// we can safely return no posts.
+		var lastTime int64
+		if err := s.rootStore.doStandardReadCache(s.rootStore.lastPostTimeCache, options.ChannelId, &lastTime); err == nil && lastTime <= options.Time {
+			list := model.NewPostList()
+			return list, nil
+		}
+	}
+
+	list, err := s.PostStore.GetPostsSince(options, allowFromCache, sanitizeOptions)
+
+	latestUpdate := options.Time
+	if err == nil {
+		for _, p := range list.ToSlice() {
+			if latestUpdate < p.UpdateAt {
+				latestUpdate = p.UpdateAt
+			}
+		}
+		s.rootStore.doStandardAddToCache(s.rootStore.lastPostTimeCache, options.ChannelId, latestUpdate)
+	}
+
+	return list, err
+}
+
+func (s LocalCachePostStore) GetPosts(options model.GetPostsOptions, allowFromCache bool, sanitizeOptions map[string]bool) (*model.PostList, error) {
+	if !allowFromCache {
+		return s.PostStore.GetPosts(options, allowFromCache, sanitizeOptions)
+	}
+
+	offset := options.PerPage * options.Page
+	// Caching only occurs on limits of 30 and 60, the common limits requested by MM clients
+	if offset == 0 && (options.PerPage == 60 || options.PerPage == 30) {
+		var cacheItem *model.PostList
+		if err := s.rootStore.doStandardReadCache(s.rootStore.postLastPostsCache, fmt.Sprintf("%s%v", options.ChannelId, options.PerPage), &cacheItem); err == nil {
+			return cacheItem, nil
+		}
+	}
+
+	list, err := s.PostStore.GetPosts(options, false, sanitizeOptions)
+	if err != nil {
+		return nil, err
+	}
+
+	// Caching only occurs on limits of 30 and 60, the common limits requested by MM clients
+	if offset == 0 && (options.PerPage == 60 || options.PerPage == 30) {
+		s.rootStore.doStandardAddToCache(s.rootStore.postLastPostsCache, fmt.Sprintf("%s%v", options.ChannelId, options.PerPage), list)
+	}
+
+	return list, err
+}
+
+// AnalyticsPostCount looks up cache only when ExcludeDeleted and UsersPostsOnly are true and rest are falsy.
+func (s LocalCachePostStore) AnalyticsPostCount(options *model.PostCountOptions) (int64, error) {
+	if !options.AllowFromCache || options.MustHaveFile || options.MustHaveHashtag || !options.UsersPostsOnly || !options.ExcludeDeleted || options.TeamId != "" {
+		return s.PostStore.AnalyticsPostCount(options)
+	}
+
+	// Currently cache only for app > usage > GetPostsUsage()
+	// Other filter combinations can be cached if required
+	cacheKey := "posts_usage"
+	var count int64
+	if err := s.rootStore.doStandardReadCache(s.rootStore.postsUsageCache, cacheKey, &count); err == nil {
+		return count, nil
+	}
+
+	count, err := s.PostStore.AnalyticsPostCount(options)
+	if err != nil {
+		return 0, err
+	}
+
+	s.rootStore.doStandardAddToCache(s.rootStore.postsUsageCache, cacheKey, count)
+	return count, nil
+}

server/channels/store/localcachelayer/post_layer_test.go

@@ -0,0 +1,195 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestPostStore(t *testing.T) {
+	StoreTestWithSqlStore(t, storetest.TestPostStore)
+}
+
+func TestPostStoreLastPostTimeCache(t *testing.T) {
+	var fakeLastTime int64 = 1
+	channelId := "channelId"
+	fakeOptions := model.GetPostsSinceOptions{
+		ChannelId:        channelId,
+		Time:             fakeLastTime,
+		SkipFetchThreads: false,
+	}
+
+	t.Run("GetEtag: first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		expectedResult := fmt.Sprintf("%v.%v", model.CurrentVersion, fakeLastTime)
+
+		etag := cachedStore.Post().GetEtag(channelId, true, false)
+		assert.Equal(t, etag, expectedResult)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
+
+		etag = cachedStore.Post().GetEtag(channelId, true, false)
+		assert.Equal(t, etag, expectedResult)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
+	})
+
+	t.Run("GetEtag: first call not cached, second force no cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Post().GetEtag(channelId, true, false)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
+		cachedStore.Post().GetEtag(channelId, false, false)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 2)
+	})
+
+	t.Run("GetEtag: first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Post().GetEtag(channelId, true, false)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
+		cachedStore.Post().InvalidateLastPostTimeCache(channelId)
+		cachedStore.Post().GetEtag(channelId, true, false)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 2)
+	})
+
+	t.Run("GetEtag: first call not cached, clear caches, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Post().GetEtag(channelId, true, false)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 1)
+		cachedStore.Post().ClearCaches()
+		cachedStore.Post().GetEtag(channelId, true, false)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetEtag", 2)
+	})
+
+	t.Run("GetPostsSince: first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		expectedResult := model.NewPostList()
+
+		list, err := cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
+		require.NoError(t, err)
+		assert.Equal(t, list, expectedResult)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
+
+		list, err = cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
+		require.NoError(t, err)
+		assert.Equal(t, list, expectedResult)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
+	})
+
+	t.Run("GetPostsSince: first call not cached, second force no cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
+		cachedStore.Post().GetPostsSince(fakeOptions, false, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2)
+	})
+
+	t.Run("GetPostsSince: first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
+		cachedStore.Post().InvalidateLastPostTimeCache(channelId)
+		cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2)
+	})
+
+	t.Run("GetPostsSince: first call not cached, clear caches, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 1)
+		cachedStore.Post().ClearCaches()
+		cachedStore.Post().GetPostsSince(fakeOptions, true, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPostsSince", 2)
+	})
+}
+
+func TestPostStoreCache(t *testing.T) {
+	fakePosts := &model.PostList{}
+	fakeOptions := model.GetPostsOptions{ChannelId: "123", PerPage: 30}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
+		require.NoError(t, err)
+		assert.Equal(t, fakePosts, gotPosts)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
+
+		_, _ = cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
+		require.NoError(t, err)
+		assert.Equal(t, fakePosts, gotPosts)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
+
+		_, _ = cachedStore.Post().GetPosts(fakeOptions, false, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 2)
+	})
+
+	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotPosts, err := cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
+		require.NoError(t, err)
+		assert.Equal(t, fakePosts, gotPosts)
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
+
+		cachedStore.Post().InvalidateLastPostTimeCache("12360")
+
+		_, _ = cachedStore.Post().GetPosts(fakeOptions, true, map[string]bool{})
+		mockStore.Post().(*mocks.PostStore).AssertNumberOfCalls(t, "GetPosts", 1)
+
+	})
+}

server/channels/store/localcachelayer/reaction_layer.go

@@ -0,0 +1,61 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCacheReactionStore struct {
+	store.ReactionStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheReactionStore) handleClusterInvalidateReaction(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.reactionCache.Purge()
+	} else {
+		s.rootStore.reactionCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCacheReactionStore) Save(reaction *model.Reaction) (*model.Reaction, error) {
+	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.reactionCache, reaction.PostId)
+	return s.ReactionStore.Save(reaction)
+}
+
+func (s LocalCacheReactionStore) Delete(reaction *model.Reaction) (*model.Reaction, error) {
+	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.reactionCache, reaction.PostId)
+	return s.ReactionStore.Delete(reaction)
+}
+
+func (s LocalCacheReactionStore) GetForPost(postId string, allowFromCache bool) ([]*model.Reaction, error) {
+	if !allowFromCache {
+		return s.ReactionStore.GetForPost(postId, false)
+	}
+
+	var reaction []*model.Reaction
+	if err := s.rootStore.doStandardReadCache(s.rootStore.reactionCache, postId, &reaction); err == nil {
+		return reaction, nil
+	}
+
+	reaction, err := s.ReactionStore.GetForPost(postId, false)
+	if err != nil {
+		return nil, err
+	}
+
+	s.rootStore.doStandardAddToCache(s.rootStore.reactionCache, postId, reaction)
+
+	return reaction, nil
+}
+
+func (s LocalCacheReactionStore) DeleteAllWithEmojiName(emojiName string) error {
+	// This could be improved. Right now we just clear the whole
+	// cache because we don't have a way find what post Ids have this emoji name.
+	defer s.rootStore.doClearCacheCluster(s.rootStore.reactionCache)
+	return s.ReactionStore.DeleteAllWithEmojiName(emojiName)
+}

server/channels/store/localcachelayer/reaction_layer_test.go

@@ -0,0 +1,76 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestReactionStore(t *testing.T) {
+	StoreTestWithSqlStore(t, storetest.TestReactionStore)
+}
+
+func TestReactionStoreCache(t *testing.T) {
+	fakeReaction := model.Reaction{PostId: "123"}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		reaction, err := cachedStore.Reaction().GetForPost("123", true)
+		require.NoError(t, err)
+		assert.Equal(t, reaction, []*model.Reaction{&fakeReaction})
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
+		assert.Equal(t, reaction, []*model.Reaction{&fakeReaction})
+		cachedStore.Reaction().GetForPost("123", true)
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Reaction().GetForPost("123", true)
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
+		cachedStore.Reaction().GetForPost("123", false)
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 2)
+	})
+
+	t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Reaction().GetForPost("123", true)
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
+		cachedStore.Reaction().Save(&fakeReaction)
+		cachedStore.Reaction().GetForPost("123", true)
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 2)
+	})
+
+	t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Reaction().GetForPost("123", true)
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 1)
+		cachedStore.Reaction().Delete(&fakeReaction)
+		cachedStore.Reaction().GetForPost("123", true)
+		mockStore.Reaction().(*mocks.ReactionStore).AssertNumberOfCalls(t, "GetForPost", 2)
+	})
+}

server/channels/store/localcachelayer/role_layer.go

@@ -0,0 +1,117 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+	"context"
+	"sort"
+	"strings"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCacheRoleStore struct {
+	store.RoleStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheRoleStore) handleClusterInvalidateRole(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.roleCache.Purge()
+	} else {
+		s.rootStore.roleCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheRoleStore) handleClusterInvalidateRolePermissions(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.rolePermissionsCache.Purge()
+	} else {
+		s.rootStore.rolePermissionsCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCacheRoleStore) Save(role *model.Role) (*model.Role, error) {
+	if role.Name != "" {
+		defer s.rootStore.doInvalidateCacheCluster(s.rootStore.roleCache, role.Name)
+		defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
+	}
+	return s.RoleStore.Save(role)
+}
+
+func (s LocalCacheRoleStore) GetByName(ctx context.Context, name string) (*model.Role, error) {
+	var role *model.Role
+	if err := s.rootStore.doStandardReadCache(s.rootStore.roleCache, name, &role); err == nil {
+		return role, nil
+	}
+
+	role, err := s.RoleStore.GetByName(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+	s.rootStore.doStandardAddToCache(s.rootStore.roleCache, name, role)
+	return role, nil
+}
+
+func (s LocalCacheRoleStore) GetByNames(names []string) ([]*model.Role, error) {
+	var foundRoles []*model.Role
+	var rolesToQuery []string
+
+	for _, roleName := range names {
+		var role *model.Role
+		if err := s.rootStore.doStandardReadCache(s.rootStore.roleCache, roleName, &role); err == nil {
+			foundRoles = append(foundRoles, role)
+		} else {
+			rolesToQuery = append(rolesToQuery, roleName)
+		}
+	}
+
+	roles, err := s.RoleStore.GetByNames(rolesToQuery)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, role := range roles {
+		s.rootStore.doStandardAddToCache(s.rootStore.roleCache, role.Name, role)
+	}
+
+	return append(foundRoles, roles...), nil
+}
+
+func (s LocalCacheRoleStore) Delete(roleId string) (*model.Role, error) {
+	role, err := s.RoleStore.Delete(roleId)
+
+	if err == nil {
+		s.rootStore.doInvalidateCacheCluster(s.rootStore.roleCache, role.Name)
+		defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
+	}
+	return role, err
+}
+
+func (s LocalCacheRoleStore) PermanentDeleteAll() error {
+	defer s.rootStore.roleCache.Purge()
+	defer s.rootStore.doClearCacheCluster(s.rootStore.roleCache)
+	defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
+
+	return s.RoleStore.PermanentDeleteAll()
+}
+
+func (s LocalCacheRoleStore) ChannelHigherScopedPermissions(roleNames []string) (map[string]*model.RolePermissions, error) {
+	sort.Strings(roleNames)
+	cacheKey := strings.Join(roleNames, "/")
+	var rolePermissionsMap map[string]*model.RolePermissions
+	if err := s.rootStore.doStandardReadCache(s.rootStore.rolePermissionsCache, cacheKey, &rolePermissionsMap); err == nil {
+		return rolePermissionsMap, nil
+	}
+
+	rolePermissionsMap, err := s.RoleStore.ChannelHigherScopedPermissions(roleNames)
+	if err != nil {
+		return nil, err
+	}
+
+	s.rootStore.doStandardAddToCache(s.rootStore.rolePermissionsCache, cacheKey, rolePermissionsMap)
+	return rolePermissionsMap, nil
+}

server/channels/store/localcachelayer/role_layer_test.go

@@ -0,0 +1,79 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestRoleStore(t *testing.T) {
+	StoreTestWithSqlStore(t, storetest.TestRoleStore)
+}
+
+func TestRoleStoreCache(t *testing.T) {
+	fakeRole := model.Role{Id: "123", Name: "role-name"}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		role, err := cachedStore.Role().GetByName(context.Background(), "role-name")
+		require.NoError(t, err)
+		assert.Equal(t, role, &fakeRole)
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
+		require.NoError(t, err)
+		assert.Equal(t, role, &fakeRole)
+		cachedStore.Role().GetByName(context.Background(), "role-name")
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
+	})
+
+	t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Role().GetByName(context.Background(), "role-name")
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Role().Save(&fakeRole)
+		cachedStore.Role().GetByName(context.Background(), "role-name")
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 2)
+	})
+
+	t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Role().GetByName(context.Background(), "role-name")
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Role().Delete("123")
+		cachedStore.Role().GetByName(context.Background(), "role-name")
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 2)
+	})
+
+	t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Role().GetByName(context.Background(), "role-name")
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 1)
+		cachedStore.Role().PermanentDeleteAll()
+		cachedStore.Role().GetByName(context.Background(), "role-name")
+		mockStore.Role().(*mocks.RoleStore).AssertNumberOfCalls(t, "GetByName", 2)
+	})
+}

server/channels/store/localcachelayer/scheme_layer.go

@@ -0,0 +1,61 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCacheSchemeStore struct {
+	store.SchemeStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheSchemeStore) handleClusterInvalidateScheme(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.schemeCache.Purge()
+	} else {
+		s.rootStore.schemeCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCacheSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
+	if scheme.Id != "" {
+		defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, scheme.Id)
+	}
+	return s.SchemeStore.Save(scheme)
+}
+
+func (s LocalCacheSchemeStore) Get(schemeId string) (*model.Scheme, error) {
+	var scheme *model.Scheme
+	if err := s.rootStore.doStandardReadCache(s.rootStore.schemeCache, schemeId, &scheme); err == nil {
+		return scheme, nil
+	}
+
+	scheme, err := s.SchemeStore.Get(schemeId)
+	if err != nil {
+		return nil, err
+	}
+
+	s.rootStore.doStandardAddToCache(s.rootStore.schemeCache, schemeId, scheme)
+
+	return scheme, nil
+}
+
+func (s LocalCacheSchemeStore) Delete(schemeId string) (*model.Scheme, error) {
+	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, schemeId)
+	defer s.rootStore.doClearCacheCluster(s.rootStore.roleCache)
+	defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
+	return s.SchemeStore.Delete(schemeId)
+}
+
+func (s LocalCacheSchemeStore) PermanentDeleteAll() error {
+	defer s.rootStore.doClearCacheCluster(s.rootStore.schemeCache)
+	defer s.rootStore.doClearCacheCluster(s.rootStore.roleCache)
+	defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
+	return s.SchemeStore.PermanentDeleteAll()
+}

server/channels/store/localcachelayer/scheme_layer_test.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestSchemeStore(t *testing.T) {
+	StoreTest(t, storetest.TestSchemeStore)
+}
+
+func TestSchemeStoreCache(t *testing.T) {
+	fakeScheme := model.Scheme{Id: "123", Name: "scheme-name"}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		scheme, err := cachedStore.Scheme().Get("123")
+		require.NoError(t, err)
+		assert.Equal(t, scheme, &fakeScheme)
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
+		require.NoError(t, err)
+		assert.Equal(t, scheme, &fakeScheme)
+		cachedStore.Scheme().Get("123")
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
+	})
+
+	t.Run("first call not cached, save, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Scheme().Get("123")
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Scheme().Save(&fakeScheme)
+		cachedStore.Scheme().Get("123")
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call not cached, delete, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Scheme().Get("123")
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Scheme().Delete("123")
+		cachedStore.Scheme().Get("123")
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call not cached, permanent delete all, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Scheme().Get("123")
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.Scheme().PermanentDeleteAll()
+		cachedStore.Scheme().Get("123")
+		mockStore.Scheme().(*mocks.SchemeStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+}

server/channels/store/localcachelayer/team_layer.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCacheTeamStore struct {
+	store.TeamStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheTeamStore) handleClusterInvalidateTeam(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.teamAllTeamIdsForUserCache.Purge()
+	} else {
+		s.rootStore.teamAllTeamIdsForUserCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCacheTeamStore) ClearCaches() {
+	s.rootStore.teamAllTeamIdsForUserCache.Purge()
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("All Team Ids for User - Purge")
+	}
+}
+
+func (s LocalCacheTeamStore) InvalidateAllTeamIdsForUser(userId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.teamAllTeamIdsForUserCache, userId)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("All Team Ids for User - Remove by UserId")
+	}
+}
+
+func (s LocalCacheTeamStore) GetUserTeamIds(userID string, allowFromCache bool) ([]string, error) {
+	if !allowFromCache {
+		return s.TeamStore.GetUserTeamIds(userID, allowFromCache)
+	}
+
+	var userTeamIds []string
+	if err := s.rootStore.doStandardReadCache(s.rootStore.teamAllTeamIdsForUserCache, userID, &userTeamIds); err == nil {
+		return userTeamIds, nil
+	}
+
+	userTeamIds, err := s.TeamStore.GetUserTeamIds(userID, allowFromCache)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(userTeamIds) > 0 {
+		s.rootStore.doStandardAddToCache(s.rootStore.teamAllTeamIdsForUserCache, userID, userTeamIds)
+	}
+
+	return userTeamIds, nil
+}
+
+func (s LocalCacheTeamStore) Update(team *model.Team) (*model.Team, error) {
+	var oldTeam *model.Team
+	var err error
+	if team.DeleteAt != 0 {
+		oldTeam, err = s.TeamStore.Get(team.Id)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	tm, err := s.TeamStore.Update(team)
+	if err != nil {
+		return nil, err
+	}
+	defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
+
+	if oldTeam != nil && oldTeam.DeleteAt == 0 {
+		s.rootStore.doClearCacheCluster(s.rootStore.teamAllTeamIdsForUserCache)
+	}
+
+	return tm, err
+}

server/channels/store/localcachelayer/team_layer_test.go

@@ -0,0 +1,77 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestTeamStore(t *testing.T) {
+	StoreTest(t, storetest.TestTeamStore)
+}
+
+func TestTeamStoreCache(t *testing.T) {
+	fakeUserId := "123"
+	fakeUserTeamIds := []string{"1", "2", "3"}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
+		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
+
+		gotUserTeamIds, err = cachedStore.Team().GetUserTeamIds(fakeUserId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
+		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
+		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
+
+		gotUserTeamIds, err = cachedStore.Team().GetUserTeamIds(fakeUserId, false)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
+		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 2)
+	})
+
+	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUserTeamIds, err := cachedStore.Team().GetUserTeamIds(fakeUserId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
+		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 1)
+
+		cachedStore.Team().InvalidateAllTeamIdsForUser(fakeUserId)
+
+		gotUserTeamIds, err = cachedStore.Team().GetUserTeamIds(fakeUserId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUserTeamIds, gotUserTeamIds)
+		mockStore.Team().(*mocks.TeamStore).AssertNumberOfCalls(t, "GetUserTeamIds", 2)
+	})
+
+}

server/channels/store/localcachelayer/terms_of_service_layer.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+const (
+	LatestKey = "latest"
+)
+
+type LocalCacheTermsOfServiceStore struct {
+	store.TermsOfServiceStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheTermsOfServiceStore) handleClusterInvalidateTermsOfService(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.termsOfServiceCache.Purge()
+	} else {
+		s.rootStore.termsOfServiceCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCacheTermsOfServiceStore) ClearCaches() {
+	s.rootStore.doClearCacheCluster(s.rootStore.termsOfServiceCache)
+
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Terms Of Service - Purge")
+	}
+}
+
+func (s LocalCacheTermsOfServiceStore) Save(termsOfService *model.TermsOfService) (*model.TermsOfService, error) {
+	tos, err := s.TermsOfServiceStore.Save(termsOfService)
+
+	if err == nil {
+		s.rootStore.doStandardAddToCache(s.rootStore.termsOfServiceCache, tos.Id, tos)
+		s.rootStore.doInvalidateCacheCluster(s.rootStore.termsOfServiceCache, LatestKey)
+	}
+	return tos, err
+}
+
+func (s LocalCacheTermsOfServiceStore) GetLatest(allowFromCache bool) (*model.TermsOfService, error) {
+	if allowFromCache {
+		if len, err := s.rootStore.termsOfServiceCache.Len(); err == nil && len != 0 {
+			var cacheItem *model.TermsOfService
+			if err := s.rootStore.doStandardReadCache(s.rootStore.termsOfServiceCache, LatestKey, &cacheItem); err == nil {
+				return cacheItem, nil
+			}
+		}
+	}
+
+	termsOfService, err := s.TermsOfServiceStore.GetLatest(allowFromCache)
+
+	if allowFromCache && err == nil {
+		s.rootStore.doStandardAddToCache(s.rootStore.termsOfServiceCache, termsOfService.Id, termsOfService)
+		s.rootStore.doStandardAddToCache(s.rootStore.termsOfServiceCache, LatestKey, termsOfService)
+	}
+
+	return termsOfService, err
+}
+
+func (s LocalCacheTermsOfServiceStore) Get(id string, allowFromCache bool) (*model.TermsOfService, error) {
+	if allowFromCache {
+		var cacheItem *model.TermsOfService
+		if err := s.rootStore.doStandardReadCache(s.rootStore.termsOfServiceCache, id, &cacheItem); err == nil {
+			return cacheItem, nil
+		}
+	}
+
+	termsOfService, err := s.TermsOfServiceStore.Get(id, allowFromCache)
+
+	if allowFromCache && err == nil {
+		s.rootStore.doStandardAddToCache(s.rootStore.termsOfServiceCache, termsOfService.Id, termsOfService)
+	}
+
+	return termsOfService, err
+}

server/channels/store/localcachelayer/terms_of_service_layer_test.go

@@ -0,0 +1,146 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestTermsOfServiceStore(t *testing.T) {
+	StoreTest(t, storetest.TestTermsOfServiceStore)
+}
+
+func TestTermsOfServiceStoreTermsOfServiceCache(t *testing.T) {
+
+	fakeTermsOfService := model.TermsOfService{Id: "123", CreateAt: 11111, UserId: "321", Text: "Terms of service test"}
+
+	t.Run("first call by latest not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		termsOfService, err := cachedStore.TermsOfService().GetLatest(true)
+		require.NoError(t, err)
+		assert.Equal(t, termsOfService, &fakeTermsOfService)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
+		termsOfService, err = cachedStore.TermsOfService().GetLatest(true)
+		require.NoError(t, err)
+		assert.Equal(t, termsOfService, &fakeTermsOfService)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
+	})
+
+	t.Run("first call by id not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		termsOfService, err := cachedStore.TermsOfService().Get("123", true)
+		require.NoError(t, err)
+		assert.Equal(t, termsOfService, &fakeTermsOfService)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
+		termsOfService, err = cachedStore.TermsOfService().Get("123", true)
+		require.NoError(t, err)
+		assert.Equal(t, termsOfService, &fakeTermsOfService)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
+	})
+
+	t.Run("first call by id not cached, second force no cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.TermsOfService().Get("123", true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.TermsOfService().Get("123", false)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call latest not cached, second force no cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.TermsOfService().GetLatest(true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
+		cachedStore.TermsOfService().GetLatest(false)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 2)
+	})
+
+	t.Run("first call by id force no cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.TermsOfService().Get("123", false)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.TermsOfService().Get("123", true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 2)
+		cachedStore.TermsOfService().Get("123", true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first call latest force no cached, second not cached, third cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.TermsOfService().GetLatest(false)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
+		cachedStore.TermsOfService().GetLatest(true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 2)
+		cachedStore.TermsOfService().GetLatest(true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 2)
+	})
+
+	t.Run("first call latest, second call by id cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.TermsOfService().GetLatest(true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
+		cachedStore.TermsOfService().Get("123", true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 0)
+	})
+
+	t.Run("first call by id not cached, save, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.TermsOfService().Get("123", false)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 1)
+		cachedStore.TermsOfService().Save(&fakeTermsOfService)
+		cachedStore.TermsOfService().Get("123", false)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("first get latest not cached, save new, then get latest, returning different data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.TermsOfService().GetLatest(true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 1)
+		cachedStore.TermsOfService().Save(&fakeTermsOfService)
+		cachedStore.TermsOfService().GetLatest(true)
+		mockStore.TermsOfService().(*mocks.TermsOfServiceStore).AssertNumberOfCalls(t, "GetLatest", 2)
+	})
+}

server/channels/store/localcachelayer/user_layer.go

@@ -0,0 +1,263 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+	"context"
+	"sort"
+	"sync"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/sqlstore"
+)
+
+type LocalCacheUserStore struct {
+	store.UserStore
+	rootStore                     *LocalCacheStore
+	userProfileByIdsMut           sync.Mutex
+	userProfileByIdsInvalidations map[string]bool
+}
+
+func (s *LocalCacheUserStore) handleClusterInvalidateScheme(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.userProfileByIdsCache.Purge()
+	} else {
+		s.userProfileByIdsMut.Lock()
+		s.userProfileByIdsInvalidations[string(msg.Data)] = true
+		s.userProfileByIdsMut.Unlock()
+		s.rootStore.userProfileByIdsCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheUserStore) handleClusterInvalidateProfilesInChannel(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.profilesInChannelCache.Purge()
+	} else {
+		s.rootStore.profilesInChannelCache.Remove(string(msg.Data))
+	}
+}
+
+func (s *LocalCacheUserStore) ClearCaches() {
+	s.rootStore.userProfileByIdsCache.Purge()
+	s.rootStore.profilesInChannelCache.Purge()
+
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profile By Ids - Purge")
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profiles in Channel - Purge")
+	}
+}
+
+func (s *LocalCacheUserStore) InvalidateProfileCacheForUser(userId string) {
+	s.userProfileByIdsMut.Lock()
+	s.userProfileByIdsInvalidations[userId] = true
+	s.userProfileByIdsMut.Unlock()
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.userProfileByIdsCache, userId)
+
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profile By Ids - Remove")
+	}
+}
+
+func (s *LocalCacheUserStore) InvalidateProfilesInChannelCacheByUser(userId string) {
+	keys, err := s.rootStore.profilesInChannelCache.Keys()
+	if err == nil {
+		for _, key := range keys {
+			var userMap map[string]*model.User
+			if err = s.rootStore.profilesInChannelCache.Get(key, &userMap); err == nil {
+				if _, userInCache := userMap[userId]; userInCache {
+					s.rootStore.doInvalidateCacheCluster(s.rootStore.profilesInChannelCache, key)
+					if s.rootStore.metrics != nil {
+						s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profiles in Channel - Remove by User")
+					}
+				}
+			}
+		}
+	}
+}
+
+func (s *LocalCacheUserStore) InvalidateProfilesInChannelCache(channelID string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.profilesInChannelCache, channelID)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Profiles in Channel - Remove by Channel")
+	}
+}
+
+func (s *LocalCacheUserStore) GetAllProfilesInChannel(ctx context.Context, channelId string, allowFromCache bool) (map[string]*model.User, error) {
+	if allowFromCache {
+		var cachedMap map[string]*model.User
+		if err := s.rootStore.doStandardReadCache(s.rootStore.profilesInChannelCache, channelId, &cachedMap); err == nil {
+			return cachedMap, nil
+		}
+	}
+
+	userMap, err := s.UserStore.GetAllProfilesInChannel(ctx, channelId, allowFromCache)
+	if err != nil {
+		return nil, err
+	}
+
+	if allowFromCache {
+		s.rootStore.doStandardAddToCache(s.rootStore.profilesInChannelCache, channelId, model.UserMap(userMap))
+	}
+
+	return userMap, nil
+}
+
+func (s *LocalCacheUserStore) GetProfileByIds(ctx context.Context, userIds []string, options *store.UserGetByIdsOpts, allowFromCache bool) ([]*model.User, error) {
+	if !allowFromCache {
+		return s.UserStore.GetProfileByIds(ctx, userIds, options, false)
+	}
+
+	if options == nil {
+		options = &store.UserGetByIdsOpts{}
+	}
+
+	users := []*model.User{}
+	remainingUserIds := make([]string, 0)
+
+	fromMaster := false
+	for _, userId := range userIds {
+		var cacheItem *model.User
+		if err := s.rootStore.doStandardReadCache(s.rootStore.userProfileByIdsCache, userId, &cacheItem); err == nil {
+			if options.Since == 0 || cacheItem.UpdateAt > options.Since {
+				users = append(users, cacheItem)
+			}
+		} else {
+			// If it was invalidated, then we need to query master.
+			s.userProfileByIdsMut.Lock()
+			if s.userProfileByIdsInvalidations[userId] {
+				fromMaster = true
+				// And then remove the key from the map.
+				delete(s.userProfileByIdsInvalidations, userId)
+			}
+			s.userProfileByIdsMut.Unlock()
+			remainingUserIds = append(remainingUserIds, userId)
+		}
+	}
+
+	if len(remainingUserIds) > 0 {
+		if fromMaster {
+			ctx = sqlstore.WithMaster(ctx)
+		}
+		remainingUsers, err := s.UserStore.GetProfileByIds(ctx, remainingUserIds, options, false)
+		if err != nil {
+			return nil, err
+		}
+		for _, user := range remainingUsers {
+			s.rootStore.doStandardAddToCache(s.rootStore.userProfileByIdsCache, user.Id, user)
+			users = append(users, user)
+		}
+	}
+
+	return users, nil
+}
+
+// Get is a cache wrapper around the SqlStore method to get a user profile by id.
+// It checks if the user entry is present in the cache, returning the entry from cache
+// if it is present. Otherwise, it fetches the entry from the store and stores it in the
+// cache.
+func (s *LocalCacheUserStore) Get(ctx context.Context, id string) (*model.User, error) {
+	var cacheItem *model.User
+	if err := s.rootStore.doStandardReadCache(s.rootStore.userProfileByIdsCache, id, &cacheItem); err == nil {
+		if s.rootStore.metrics != nil {
+			s.rootStore.metrics.AddMemCacheHitCounter("Profile By Id", float64(1))
+		}
+		return cacheItem, nil
+	}
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.AddMemCacheMissCounter("Profile By Id", float64(1))
+	}
+
+	// If it was invalidated, then we need to query master.
+	s.userProfileByIdsMut.Lock()
+	if s.userProfileByIdsInvalidations[id] {
+		ctx = sqlstore.WithMaster(ctx)
+		// And then remove the key from the map.
+		delete(s.userProfileByIdsInvalidations, id)
+	}
+	s.userProfileByIdsMut.Unlock()
+
+	user, err := s.UserStore.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	s.rootStore.doStandardAddToCache(s.rootStore.userProfileByIdsCache, id, user)
+	return user, nil
+}
+
+// GetMany is a cache wrapper around the SqlStore method to get a user profiles by ids.
+// It checks if the user entries are present in the cache, returning the entries from cache
+// if it is present. Otherwise, it fetches the entries from the store and stores it in the
+// cache.
+func (s *LocalCacheUserStore) GetMany(ctx context.Context, ids []string) ([]*model.User, error) {
+	// we are doing a loop instead of caching the full set in the cache because the number of permutations that we can have
+	// in this func is making caching of the total set not beneficial.
+	var cachedUsers []*model.User
+	var notCachedUserIds []string
+	uniqIDs := dedup(ids)
+
+	fromMaster := false
+	for _, id := range uniqIDs {
+		var cachedUser *model.User
+		if err := s.rootStore.doStandardReadCache(s.rootStore.userProfileByIdsCache, id, &cachedUser); err == nil {
+			if s.rootStore.metrics != nil {
+				s.rootStore.metrics.AddMemCacheHitCounter("Profile By Id", float64(1))
+			}
+			cachedUsers = append(cachedUsers, cachedUser)
+		} else {
+			if s.rootStore.metrics != nil {
+				s.rootStore.metrics.AddMemCacheMissCounter("Profile By Id", float64(1))
+			}
+			// If it was invalidated, then we need to query master.
+			s.userProfileByIdsMut.Lock()
+			if s.userProfileByIdsInvalidations[id] {
+				fromMaster = true
+				// And then remove the key from the map.
+				delete(s.userProfileByIdsInvalidations, id)
+			}
+			s.userProfileByIdsMut.Unlock()
+
+			notCachedUserIds = append(notCachedUserIds, id)
+		}
+	}
+
+	if len(notCachedUserIds) > 0 {
+		if fromMaster {
+			ctx = sqlstore.WithMaster(ctx)
+		}
+		dbUsers, err := s.UserStore.GetMany(ctx, notCachedUserIds)
+		if err != nil {
+			return nil, err
+		}
+		for _, user := range dbUsers {
+			s.rootStore.doStandardAddToCache(s.rootStore.userProfileByIdsCache, user.Id, user)
+			cachedUsers = append(cachedUsers, user)
+		}
+	}
+
+	return cachedUsers, nil
+}
+
+func dedup(elements []string) []string {
+	if len(elements) == 0 {
+		return elements
+	}
+
+	sort.Strings(elements)
+
+	j := 0
+	for i := 1; i < len(elements); i++ {
+		if elements[j] == elements[i] {
+			continue
+		}
+		j++
+		// preserve the original data
+		// in[i], in[j] = in[j], in[i]
+		// only set what is required
+		elements[j] = elements[i]
+	}
+
+	return elements[:j+1]
+}

server/channels/store/localcachelayer/user_layer_test.go

@@ -0,0 +1,313 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/plugin/plugintest/mock"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestUserStore(t *testing.T) {
+	StoreTestWithSqlStore(t, storetest.TestUserStore)
+}
+
+func TestUserStoreCache(t *testing.T) {
+	fakeUserIds := []string{"123"}
+	fakeUser := []*model.User{{
+		Id:          "123",
+		AuthData:    model.NewString("authData"),
+		AuthService: "authService",
+	}}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUser, err := cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUser, gotUser)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetProfileByIds", 1)
+
+		_, _ = cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, true)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetProfileByIds", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUser, err := cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUser, gotUser)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetProfileByIds", 1)
+
+		_, _ = cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, false)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetProfileByIds", 2)
+	})
+
+	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUser, err := cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUser, gotUser)
+
+		cachedStore.User().InvalidateProfileCacheForUser("123")
+
+		_, _ = cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, true)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetProfileByIds", 2)
+	})
+
+	t.Run("should always return a copy of the stored data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		storedUsers, err := mockStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, false)
+		require.NoError(t, err)
+
+		originalProps := make([]model.StringMap, len(storedUsers))
+
+		for i := 0; i < len(storedUsers); i++ {
+			originalProps[i] = storedUsers[i].NotifyProps
+			storedUsers[i].NotifyProps = map[string]string{}
+			storedUsers[i].NotifyProps["key"] = "somevalue"
+		}
+
+		cachedUsers, err := cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, true)
+		require.NoError(t, err)
+
+		for i := 0; i < len(storedUsers); i++ {
+			assert.Equal(t, storedUsers[i].Id, cachedUsers[i].Id)
+		}
+
+		cachedUsers, err = cachedStore.User().GetProfileByIds(context.Background(), fakeUserIds, &store.UserGetByIdsOpts{}, true)
+		require.NoError(t, err)
+		for i := 0; i < len(storedUsers); i++ {
+			storedUsers[i].Props = model.StringMap{}
+			storedUsers[i].Timezone = model.StringMap{}
+			assert.Equal(t, storedUsers[i], cachedUsers[i])
+			if storedUsers[i] == cachedUsers[i] {
+				assert.Fail(t, "should be different pointers")
+			}
+			cachedUsers[i].NotifyProps["key"] = "othervalue"
+			assert.NotEqual(t, storedUsers[i], cachedUsers[i])
+		}
+
+		for i := 0; i < len(storedUsers); i++ {
+			storedUsers[i].NotifyProps = originalProps[i]
+		}
+	})
+}
+
+func TestUserStoreProfilesInChannelCache(t *testing.T) {
+	fakeChannelId := "123"
+	fakeUserId := "456"
+	fakeMap := map[string]*model.User{
+		fakeUserId: {Id: "456"},
+	}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotMap, err := cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeMap, gotMap)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
+
+		_, _ = cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, true)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotMap, err := cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeMap, gotMap)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
+
+		_, _ = cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, false)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 2)
+	})
+
+	t.Run("first call not cached, invalidate by channel, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotMap, err := cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeMap, gotMap)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
+
+		cachedStore.User().InvalidateProfilesInChannelCache("123")
+
+		_, _ = cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, true)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 2)
+	})
+
+	t.Run("first call not cached, invalidate by user, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotMap, err := cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, true)
+		require.NoError(t, err)
+		assert.Equal(t, fakeMap, gotMap)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 1)
+
+		cachedStore.User().InvalidateProfilesInChannelCacheByUser("456")
+
+		_, _ = cachedStore.User().GetAllProfilesInChannel(context.Background(), fakeChannelId, true)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetAllProfilesInChannel", 2)
+	})
+}
+
+func TestUserStoreGetCache(t *testing.T) {
+	fakeUserId := "123"
+	fakeUser := &model.User{
+		Id:          "123",
+		AuthData:    model.NewString("authData"),
+		AuthService: "authService",
+	}
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUser, err := cachedStore.User().Get(context.Background(), fakeUserId)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUser, gotUser)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "Get", 1)
+
+		_, _ = cachedStore.User().Get(context.Background(), fakeUserId)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "Get", 1)
+	})
+
+	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUser, err := cachedStore.User().Get(context.Background(), fakeUserId)
+		require.NoError(t, err)
+		assert.Equal(t, fakeUser, gotUser)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "Get", 1)
+
+		cachedStore.User().InvalidateProfileCacheForUser("123")
+
+		_, _ = cachedStore.User().Get(context.Background(), fakeUserId)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "Get", 2)
+	})
+
+	t.Run("should always return a copy of the stored data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		storedUser, err := mockStore.User().Get(context.Background(), fakeUserId)
+		require.NoError(t, err)
+		originalProps := storedUser.NotifyProps
+
+		storedUser.NotifyProps = map[string]string{}
+		storedUser.NotifyProps["key"] = "somevalue"
+
+		cachedUser, err := cachedStore.User().Get(context.Background(), fakeUserId)
+		require.NoError(t, err)
+		assert.Equal(t, storedUser, cachedUser)
+
+		storedUser.Props = model.StringMap{}
+		storedUser.Timezone = model.StringMap{}
+		cachedUser, err = cachedStore.User().Get(context.Background(), fakeUserId)
+		require.NoError(t, err)
+		assert.Equal(t, storedUser, cachedUser)
+		if storedUser == cachedUser {
+			assert.Fail(t, "should be different pointers")
+		}
+		cachedUser.NotifyProps["key"] = "othervalue"
+		assert.NotEqual(t, storedUser, cachedUser)
+
+		storedUser.NotifyProps = originalProps
+	})
+}
+
+func TestUserStoreGetManyCache(t *testing.T) {
+	fakeUser := &model.User{
+		Id:          "123",
+		AuthData:    model.NewString("authData"),
+		AuthService: "authService",
+	}
+	otherFakeUser := &model.User{
+		Id:          "456",
+		AuthData:    model.NewString("authData"),
+		AuthService: "authService",
+	}
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUsers, err := cachedStore.User().GetMany(context.Background(), []string{fakeUser.Id, otherFakeUser.Id})
+		require.NoError(t, err)
+		assert.Len(t, gotUsers, 2)
+		assert.Contains(t, gotUsers, fakeUser)
+		assert.Contains(t, gotUsers, otherFakeUser)
+
+		gotUsers, err = cachedStore.User().GetMany(context.Background(), []string{fakeUser.Id, otherFakeUser.Id})
+		require.NoError(t, err)
+		assert.Len(t, gotUsers, 2)
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetMany", 1)
+	})
+
+	t.Run("first call not cached, invalidate one user, and then check that one is cached and one is fetched from db", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		gotUsers, err := cachedStore.User().GetMany(context.Background(), []string{fakeUser.Id, otherFakeUser.Id})
+		require.NoError(t, err)
+		assert.Len(t, gotUsers, 2)
+		assert.Contains(t, gotUsers, fakeUser)
+		assert.Contains(t, gotUsers, otherFakeUser)
+
+		cachedStore.User().InvalidateProfileCacheForUser("123")
+
+		gotUsers, err = cachedStore.User().GetMany(context.Background(), []string{fakeUser.Id, otherFakeUser.Id})
+		require.NoError(t, err)
+		assert.Len(t, gotUsers, 2)
+		mockStore.User().(*mocks.UserStore).AssertCalled(t, "GetMany", mock.Anything, []string{"123"})
+		mockStore.User().(*mocks.UserStore).AssertNumberOfCalls(t, "GetMany", 2)
+	})
+}

server/channels/store/localcachelayer/webhook_layer.go

@@ -0,0 +1,89 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"bytes"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+)
+
+type LocalCacheWebhookStore struct {
+	store.WebhookStore
+	rootStore *LocalCacheStore
+}
+
+func (s *LocalCacheWebhookStore) handleClusterInvalidateWebhook(msg *model.ClusterMessage) {
+	if bytes.Equal(msg.Data, clearCacheMessageData) {
+		s.rootStore.webhookCache.Purge()
+	} else {
+		s.rootStore.webhookCache.Remove(string(msg.Data))
+	}
+}
+
+func (s LocalCacheWebhookStore) ClearCaches() {
+	s.rootStore.doClearCacheCluster(s.rootStore.webhookCache)
+
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Webhook - Purge")
+	}
+}
+
+func (s LocalCacheWebhookStore) InvalidateWebhookCache(webhookId string) {
+	s.rootStore.doInvalidateCacheCluster(s.rootStore.webhookCache, webhookId)
+	if s.rootStore.metrics != nil {
+		s.rootStore.metrics.IncrementMemCacheInvalidationCounter("Webhook - Remove by WebhookId")
+	}
+}
+
+func (s LocalCacheWebhookStore) GetIncoming(id string, allowFromCache bool) (*model.IncomingWebhook, error) {
+	if !allowFromCache {
+		return s.WebhookStore.GetIncoming(id, allowFromCache)
+	}
+
+	var incomingWebhook *model.IncomingWebhook
+	if err := s.rootStore.doStandardReadCache(s.rootStore.webhookCache, id, &incomingWebhook); err == nil {
+		return incomingWebhook, nil
+	}
+
+	incomingWebhook, err := s.WebhookStore.GetIncoming(id, allowFromCache)
+	if err != nil {
+		return nil, err
+	}
+
+	s.rootStore.doStandardAddToCache(s.rootStore.webhookCache, id, incomingWebhook)
+
+	return incomingWebhook, nil
+}
+
+func (s LocalCacheWebhookStore) DeleteIncoming(webhookId string, time int64) error {
+	err := s.WebhookStore.DeleteIncoming(webhookId, time)
+	if err != nil {
+		return err
+	}
+
+	s.InvalidateWebhookCache(webhookId)
+	return nil
+}
+
+func (s LocalCacheWebhookStore) PermanentDeleteIncomingByUser(userId string) error {
+	err := s.WebhookStore.PermanentDeleteIncomingByUser(userId)
+	if err != nil {
+		return err
+	}
+
+	s.ClearCaches()
+	return nil
+}
+
+func (s LocalCacheWebhookStore) PermanentDeleteIncomingByChannel(channelId string) error {
+	err := s.WebhookStore.PermanentDeleteIncomingByChannel(channelId)
+	if err != nil {
+		return err
+	}
+
+	s.ClearCaches()
+	return nil
+}

server/channels/store/localcachelayer/webhook_layer_test.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package localcachelayer
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+func TestWebhookStore(t *testing.T) {
+	StoreTest(t, storetest.TestWebhookStore)
+}
+
+func TestWebhookStoreCache(t *testing.T) {
+	fakeWebhook := model.IncomingWebhook{Id: "123"}
+
+	t.Run("first call not cached, second cached and returning same data", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		incomingWebhook, err := cachedStore.Webhook().GetIncoming("123", true)
+		require.NoError(t, err)
+		assert.Equal(t, incomingWebhook, &fakeWebhook)
+		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 1)
+
+		assert.Equal(t, incomingWebhook, &fakeWebhook)
+		cachedStore.Webhook().GetIncoming("123", true)
+		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 1)
+	})
+
+	t.Run("first call not cached, second force not cached", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Webhook().GetIncoming("123", true)
+		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 1)
+		cachedStore.Webhook().GetIncoming("123", false)
+		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 2)
+	})
+
+	t.Run("first call not cached, invalidate, and then not cached again", func(t *testing.T) {
+		mockStore := getMockStore()
+		mockCacheProvider := getMockCacheProvider()
+		cachedStore, err := NewLocalCacheLayer(mockStore, nil, nil, mockCacheProvider)
+		require.NoError(t, err)
+
+		cachedStore.Webhook().GetIncoming("123", true)
+		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 1)
+		cachedStore.Webhook().InvalidateWebhookCache("123")
+		cachedStore.Webhook().GetIncoming("123", true)
+		mockStore.Webhook().(*mocks.WebhookStore).AssertNumberOfCalls(t, "GetIncoming", 2)
+	})
+}