[MM-26812] Add support for resumable file uploads (#15252)

* Implement AppendFile for FileBackend

* Split test into subtests

* [MM-26812] Add support for resumable file uploads (#15252)

* Implement UploadSession

* Implement UploadSessionStore

* Add error strings

* Implement resumable file uploads

* Add UploadType

* Fix retry layer tests

* Regenerate store layers

* Fix store error handling

* Use base for filename

* Prevent concurrent uploads on the same upload session

* Fix erroneus error string

* Improve error handling

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>

* Fix translations

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>

store/opentracinglayer/opentracinglayer.go

@@ -45,6 +45,7 @@ type OpenTracingLayer struct {
 	TeamStore                 store.TeamStore
 	TermsOfServiceStore       store.TermsOfServiceStore
 	TokenStore                store.TokenStore
+	UploadSessionStore        store.UploadSessionStore
 	UserStore                 store.UserStore
 	UserAccessTokenStore      store.UserAccessTokenStore
 	UserTermsOfServiceStore   store.UserTermsOfServiceStore
@@ -159,6 +160,10 @@ func (s *OpenTracingLayer) Token() store.TokenStore {
 	return s.TokenStore
 }
 
+func (s *OpenTracingLayer) UploadSession() store.UploadSessionStore {
+	return s.UploadSessionStore
+}
+
 func (s *OpenTracingLayer) User() store.UserStore {
 	return s.UserStore
 }
@@ -310,6 +315,11 @@ type OpenTracingLayerTokenStore struct {
 	Root *OpenTracingLayer
 }
 
+type OpenTracingLayerUploadSessionStore struct {
+	store.UploadSessionStore
+	Root *OpenTracingLayer
+}
+
 type OpenTracingLayerUserStore struct {
 	store.UserStore
 	Root *OpenTracingLayer
@@ -7559,6 +7569,96 @@ func (s *OpenTracingLayerTokenStore) Save(recovery *model.Token) error {
 	return err
 }
 
+func (s *OpenTracingLayerUploadSessionStore) Delete(id string) error {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "UploadSessionStore.Delete")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	err := s.UploadSessionStore.Delete(id)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return err
+}
+
+func (s *OpenTracingLayerUploadSessionStore) Get(id string) (*model.UploadSession, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "UploadSessionStore.Get")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.UploadSessionStore.Get(id)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
+func (s *OpenTracingLayerUploadSessionStore) GetForUser(userId string) ([]*model.UploadSession, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "UploadSessionStore.GetForUser")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.UploadSessionStore.GetForUser(userId)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
+func (s *OpenTracingLayerUploadSessionStore) Save(session *model.UploadSession) (*model.UploadSession, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "UploadSessionStore.Save")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.UploadSessionStore.Save(session)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
+func (s *OpenTracingLayerUploadSessionStore) Update(session *model.UploadSession) error {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "UploadSessionStore.Update")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	err := s.UploadSessionStore.Update(session)
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return err
+}
+
 func (s *OpenTracingLayerUserStore) AnalyticsActiveCount(time int64, options model.UserCountOptions) (int64, *model.AppError) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "UserStore.AnalyticsActiveCount")
@@ -9494,6 +9594,7 @@ func New(childStore store.Store, ctx context.Context) *OpenTracingLayer {
 	newStore.TeamStore = &OpenTracingLayerTeamStore{TeamStore: childStore.Team(), Root: &newStore}
 	newStore.TermsOfServiceStore = &OpenTracingLayerTermsOfServiceStore{TermsOfServiceStore: childStore.TermsOfService(), Root: &newStore}
 	newStore.TokenStore = &OpenTracingLayerTokenStore{TokenStore: childStore.Token(), Root: &newStore}
+	newStore.UploadSessionStore = &OpenTracingLayerUploadSessionStore{UploadSessionStore: childStore.UploadSession(), Root: &newStore}
 	newStore.UserStore = &OpenTracingLayerUserStore{UserStore: childStore.User(), Root: &newStore}
 	newStore.UserAccessTokenStore = &OpenTracingLayerUserAccessTokenStore{UserAccessTokenStore: childStore.UserAccessToken(), Root: &newStore}
 	newStore.UserTermsOfServiceStore = &OpenTracingLayerUserTermsOfServiceStore{UserTermsOfServiceStore: childStore.UserTermsOfService(), Root: &newStore}

store/retrylayer/retrylayer.go

@@ -47,6 +47,7 @@ type RetryLayer struct {
 	TeamStore                 store.TeamStore
 	TermsOfServiceStore       store.TermsOfServiceStore
 	TokenStore                store.TokenStore
+	UploadSessionStore        store.UploadSessionStore
 	UserStore                 store.UserStore
 	UserAccessTokenStore      store.UserAccessTokenStore
 	UserTermsOfServiceStore   store.UserTermsOfServiceStore
@@ -161,6 +162,10 @@ func (s *RetryLayer) Token() store.TokenStore {
 	return s.TokenStore
 }
 
+func (s *RetryLayer) UploadSession() store.UploadSessionStore {
+	return s.UploadSessionStore
+}
+
 func (s *RetryLayer) User() store.UserStore {
 	return s.UserStore
 }
@@ -312,6 +317,11 @@ type RetryLayerTokenStore struct {
 	Root *RetryLayer
 }
 
+type RetryLayerUploadSessionStore struct {
+	store.UploadSessionStore
+	Root *RetryLayer
+}
+
 type RetryLayerUserStore struct {
 	store.UserStore
 	Root *RetryLayer
@@ -6542,6 +6552,106 @@ func (s *RetryLayerTokenStore) Save(recovery *model.Token) error {
 
 }
 
+func (s *RetryLayerUploadSessionStore) Delete(id string) error {
+
+	tries := 0
+	for {
+		err := s.UploadSessionStore.Delete(id)
+		if err == nil {
+			return nil
+		}
+		if !isRepeatableError(err) {
+			return err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return err
+		}
+	}
+
+}
+
+func (s *RetryLayerUploadSessionStore) Get(id string) (*model.UploadSession, error) {
+
+	tries := 0
+	for {
+		result, err := s.UploadSessionStore.Get(id)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
+
+}
+
+func (s *RetryLayerUploadSessionStore) GetForUser(userId string) ([]*model.UploadSession, error) {
+
+	tries := 0
+	for {
+		result, err := s.UploadSessionStore.GetForUser(userId)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
+
+}
+
+func (s *RetryLayerUploadSessionStore) Save(session *model.UploadSession) (*model.UploadSession, error) {
+
+	tries := 0
+	for {
+		result, err := s.UploadSessionStore.Save(session)
+		if err == nil {
+			return result, nil
+		}
+		if !isRepeatableError(err) {
+			return result, err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return result, err
+		}
+	}
+
+}
+
+func (s *RetryLayerUploadSessionStore) Update(session *model.UploadSession) error {
+
+	tries := 0
+	for {
+		err := s.UploadSessionStore.Update(session)
+		if err == nil {
+			return nil
+		}
+		if !isRepeatableError(err) {
+			return err
+		}
+		tries++
+		if tries >= 3 {
+			err = errors.Wrap(err, "giving up after 3 consecutive repeatable transaction failures")
+			return err
+		}
+	}
+
+}
+
 func (s *RetryLayerUserStore) AnalyticsActiveCount(time int64, options model.UserCountOptions) (int64, *model.AppError) {
 
 	return s.UserStore.AnalyticsActiveCount(time, options)
@@ -7782,6 +7892,7 @@ func New(childStore store.Store) *RetryLayer {
 	newStore.TeamStore = &RetryLayerTeamStore{TeamStore: childStore.Team(), Root: &newStore}
 	newStore.TermsOfServiceStore = &RetryLayerTermsOfServiceStore{TermsOfServiceStore: childStore.TermsOfService(), Root: &newStore}
 	newStore.TokenStore = &RetryLayerTokenStore{TokenStore: childStore.Token(), Root: &newStore}
+	newStore.UploadSessionStore = &RetryLayerUploadSessionStore{UploadSessionStore: childStore.UploadSession(), Root: &newStore}
 	newStore.UserStore = &RetryLayerUserStore{UserStore: childStore.User(), Root: &newStore}
 	newStore.UserAccessTokenStore = &RetryLayerUserAccessTokenStore{UserAccessTokenStore: childStore.UserAccessToken(), Root: &newStore}
 	newStore.UserTermsOfServiceStore = &RetryLayerUserTermsOfServiceStore{UserTermsOfServiceStore: childStore.UserTermsOfService(), Root: &newStore}

store/retrylayer/retrylayer_test.go

@@ -25,6 +25,7 @@ func genStore() *mocks.Store {
 	mock.On("Compliance").Return(&mocks.ComplianceStore{})
 	mock.On("Emoji").Return(&mocks.EmojiStore{})
 	mock.On("FileInfo").Return(&mocks.FileInfoStore{})
+	mock.On("UploadSession").Return(&mocks.UploadSessionStore{})
 	mock.On("Group").Return(&mocks.GroupStore{})
 	mock.On("Job").Return(&mocks.JobStore{})
 	mock.On("License").Return(&mocks.LicenseStore{})

store/sqlstore/store.go

@@ -92,6 +92,7 @@ type SqlStore interface {
 	Emoji() store.EmojiStore
 	Status() store.StatusStore
 	FileInfo() store.FileInfoStore
+	UploadSession() store.UploadSessionStore
 	Reaction() store.ReactionStore
 	Job() store.JobStore
 	Plugin() store.PluginStore

store/sqlstore/supplier.go

@@ -89,6 +89,7 @@ type SqlSupplierStores struct {
 	emoji                store.EmojiStore
 	status               store.StatusStore
 	fileInfo             store.FileInfoStore
+	uploadSession        store.UploadSessionStore
 	reaction             store.ReactionStore
 	job                  store.JobStore
 	userAccessToken      store.UserAccessTokenStore
@@ -157,6 +158,7 @@ func NewSqlSupplier(settings model.SqlSettings, metrics einterfaces.MetricsInter
 	supplier.stores.emoji = newSqlEmojiStore(supplier, metrics)
 	supplier.stores.status = newSqlStatusStore(supplier)
 	supplier.stores.fileInfo = newSqlFileInfoStore(supplier, metrics)
+	supplier.stores.uploadSession = newSqlUploadSessionStore(supplier)
 	supplier.stores.job = newSqlJobStore(supplier)
 	supplier.stores.userAccessToken = newSqlUserAccessTokenStore(supplier)
 	supplier.stores.channelMemberHistory = newSqlChannelMemberHistoryStore(supplier)
@@ -202,6 +204,7 @@ func NewSqlSupplier(settings model.SqlSettings, metrics einterfaces.MetricsInter
 	supplier.stores.emoji.(*SqlEmojiStore).createIndexesIfNotExists()
 	supplier.stores.status.(*SqlStatusStore).createIndexesIfNotExists()
 	supplier.stores.fileInfo.(*SqlFileInfoStore).createIndexesIfNotExists()
+	supplier.stores.uploadSession.(*SqlUploadSessionStore).createIndexesIfNotExists()
 	supplier.stores.job.(*SqlJobStore).createIndexesIfNotExists()
 	supplier.stores.userAccessToken.(*SqlUserAccessTokenStore).createIndexesIfNotExists()
 	supplier.stores.plugin.(*SqlPluginStore).createIndexesIfNotExists()
@@ -1134,6 +1137,10 @@ func (ss *SqlSupplier) FileInfo() store.FileInfoStore {
 	return ss.stores.fileInfo
 }
 
+func (ss *SqlSupplier) UploadSession() store.UploadSessionStore {
+	return ss.stores.uploadSession
+}
+
 func (ss *SqlSupplier) Reaction() store.ReactionStore {
 	return ss.stores.reaction
 }

store/sqlstore/upload_session_store.go

@@ -0,0 +1,133 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package sqlstore
+
+import (
+	"database/sql"
+
+	"github.com/pkg/errors"
+
+	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/store"
+
+	sq "github.com/Masterminds/squirrel"
+)
+
+type SqlUploadSessionStore struct {
+	SqlStore
+}
+
+func newSqlUploadSessionStore(sqlStore SqlStore) store.UploadSessionStore {
+	s := &SqlUploadSessionStore{
+		SqlStore: sqlStore,
+	}
+	for _, db := range sqlStore.GetAllConns() {
+		table := db.AddTableWithName(model.UploadSession{}, "UploadSessions").SetKeys(false, "Id")
+		table.ColMap("Id").SetMaxSize(26)
+		table.ColMap("Type").SetMaxSize(32)
+		table.ColMap("UserId").SetMaxSize(26)
+		table.ColMap("ChannelId").SetMaxSize(26)
+		table.ColMap("Filename").SetMaxSize(256)
+		table.ColMap("Path").SetMaxSize(512)
+	}
+	return s
+}
+
+func (us SqlUploadSessionStore) createIndexesIfNotExists() {
+	us.CreateIndexIfNotExists("idx_uploadsessions_user_id", "UploadSessions", "Type")
+	us.CreateIndexIfNotExists("idx_uploadsessions_create_at", "UploadSessions", "CreateAt")
+	us.CreateIndexIfNotExists("idx_uploadsessions_user_id", "UploadSessions", "UserId")
+}
+
+func (us SqlUploadSessionStore) Save(session *model.UploadSession) (*model.UploadSession, error) {
+	if session == nil {
+		return nil, errors.New("SqlUploadSessionStore.Save: session should not be nil")
+	}
+	session.PreSave()
+	if err := session.IsValid(); err != nil {
+		return nil, errors.Wrap(err, "SqlUploadSessionStore.Save: validation failed")
+	}
+	if err := us.GetMaster().Insert(session); err != nil {
+		return nil, errors.Wrap(err, "SqlUploadSessionStore.Save: failed to insert")
+	}
+	return session, nil
+}
+
+func (us SqlUploadSessionStore) Update(session *model.UploadSession) error {
+	if session == nil {
+		return errors.New("SqlUploadSessionStore.Update: session should not be nil")
+	}
+	if err := session.IsValid(); err != nil {
+		return errors.Wrap(err, "SqlUploadSessionStore.Update: validation failed")
+	}
+	if _, err := us.GetMaster().Update(session); err != nil {
+		if err == sql.ErrNoRows {
+			return store.NewErrNotFound("UploadSession", session.Id)
+		}
+		return errors.Wrapf(err, "SqlUploadSessionStore.Update: failed to update session with id=%s", session.Id)
+	}
+	return nil
+}
+
+func (us SqlUploadSessionStore) Get(id string) (*model.UploadSession, error) {
+	if !model.IsValidId(id) {
+		return nil, errors.New("SqlUploadSessionStore.Get: id is not valid")
+	}
+	query := us.getQueryBuilder().
+		Select("*").
+		From("UploadSessions").
+		Where(sq.Eq{"Id": id})
+	queryString, args, err := query.ToSql()
+	if err != nil {
+		return nil, errors.Wrap(err, "SqlUploadSessionStore.Get: failed to build query")
+	}
+	var session model.UploadSession
+	if err := us.GetReplica().SelectOne(&session, queryString, args...); err != nil {
+		if err == sql.ErrNoRows {
+			return nil, store.NewErrNotFound("UploadSession", id)
+		}
+		return nil, errors.Wrapf(err, "SqlUploadSessionStore.Get: failed to select session with id=%s", id)
+	}
+	return &session, nil
+}
+
+func (us SqlUploadSessionStore) GetForUser(userId string) ([]*model.UploadSession, error) {
+	if !model.IsValidId(userId) {
+		return nil, errors.New("SqlUploadSessionStore.GetForUser: userId is not valid")
+	}
+	query := us.getQueryBuilder().
+		Select("*").
+		From("UploadSessions").
+		Where(sq.Eq{"UserId": userId}).
+		OrderBy("CreateAt ASC")
+	queryString, args, err := query.ToSql()
+	if err != nil {
+		return nil, errors.Wrap(err, "SqlUploadSessionStore.GetForUser: failed to build query")
+	}
+	var sessions []*model.UploadSession
+	if _, err := us.GetReplica().Select(&sessions, queryString, args...); err != nil {
+		return nil, errors.Wrap(err, "SqlUploadSessionStore.GetForUser: failed to select")
+	}
+	return sessions, nil
+}
+
+func (us SqlUploadSessionStore) Delete(id string) error {
+	if !model.IsValidId(id) {
+		return errors.New("SqlUploadSessionStore.Delete: id is not valid")
+	}
+
+	query := us.getQueryBuilder().
+		Delete("UploadSessions").
+		Where(sq.Eq{"Id": id})
+	queryString, args, err := query.ToSql()
+	if err != nil {
+		return errors.Wrap(err, "SqlUploadSessionStore.Delete: failed to build query")
+	}
+
+	if _, err := us.GetMaster().Exec(queryString, args...); err != nil {
+		return errors.Wrap(err, "SqlUploadSessionStore.Delete: failed to delete")
+	}
+
+	return nil
+}

store/sqlstore/upload_session_store_test.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package sqlstore
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost-server/v5/store/storetest"
+)
+
+func TestUploadSessionStore(t *testing.T) {
+	StoreTest(t, storetest.TestUploadSessionStore)
+}

store/store.go

@@ -41,6 +41,7 @@ type Store interface {
 	Emoji() EmojiStore
 	Status() StatusStore
 	FileInfo() FileInfoStore
+	UploadSession() UploadSessionStore
 	Reaction() ReactionStore
 	Role() RoleStore
 	Scheme() SchemeStore
@@ -549,6 +550,14 @@ type FileInfoStore interface {
 	ClearCaches()
 }
 
+type UploadSessionStore interface {
+	Save(session *model.UploadSession) (*model.UploadSession, error)
+	Update(session *model.UploadSession) error
+	Get(id string) (*model.UploadSession, error)
+	GetForUser(userId string) ([]*model.UploadSession, error)
+	Delete(id string) error
+}
+
 type ReactionStore interface {
 	Save(reaction *model.Reaction) (*model.Reaction, error)
 	Delete(reaction *model.Reaction) (*model.Reaction, error)

store/storetest/mocks/SqlStore.go

@@ -845,6 +845,22 @@ func (_m *SqlStore) UnlockFromMaster() {
 	_m.Called()
 }
 
+// UploadSession provides a mock function with given fields:
+func (_m *SqlStore) UploadSession() store.UploadSessionStore {
+	ret := _m.Called()
+
+	var r0 store.UploadSessionStore
+	if rf, ok := ret.Get(0).(func() store.UploadSessionStore); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(store.UploadSessionStore)
+		}
+	}
+
+	return r0
+}
+
 // User provides a mock function with given fields:
 func (_m *SqlStore) User() store.UserStore {
 	ret := _m.Called()

store/storetest/mocks/Store.go

@@ -596,6 +596,22 @@ func (_m *Store) UnlockFromMaster() {
 	_m.Called()
 }
 
+// UploadSession provides a mock function with given fields:
+func (_m *Store) UploadSession() store.UploadSessionStore {
+	ret := _m.Called()
+
+	var r0 store.UploadSessionStore
+	if rf, ok := ret.Get(0).(func() store.UploadSessionStore); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(store.UploadSessionStore)
+		}
+	}
+
+	return r0
+}
+
 // User provides a mock function with given fields:
 func (_m *Store) User() store.UserStore {
 	ret := _m.Called()

store/storetest/mocks/UploadSessionStore.go

@@ -0,0 +1,112 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+// Regenerate this file using `make store-mocks`.
+
+package mocks
+
+import (
+	model "github.com/mattermost/mattermost-server/v5/model"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// UploadSessionStore is an autogenerated mock type for the UploadSessionStore type
+type UploadSessionStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: id
+func (_m *UploadSessionStore) Delete(id string) error {
+	ret := _m.Called(id)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: id
+func (_m *UploadSessionStore) Get(id string) (*model.UploadSession, error) {
+	ret := _m.Called(id)
+
+	var r0 *model.UploadSession
+	if rf, ok := ret.Get(0).(func(string) *model.UploadSession); ok {
+		r0 = rf(id)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UploadSession)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(id)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetForUser provides a mock function with given fields: userId
+func (_m *UploadSessionStore) GetForUser(userId string) ([]*model.UploadSession, error) {
+	ret := _m.Called(userId)
+
+	var r0 []*model.UploadSession
+	if rf, ok := ret.Get(0).(func(string) []*model.UploadSession); ok {
+		r0 = rf(userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.UploadSession)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
+		r1 = rf(userId)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Save provides a mock function with given fields: session
+func (_m *UploadSessionStore) Save(session *model.UploadSession) (*model.UploadSession, error) {
+	ret := _m.Called(session)
+
+	var r0 *model.UploadSession
+	if rf, ok := ret.Get(0).(func(*model.UploadSession) *model.UploadSession); ok {
+		r0 = rf(session)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.UploadSession)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*model.UploadSession) error); ok {
+		r1 = rf(session)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Update provides a mock function with given fields: session
+func (_m *UploadSessionStore) Update(session *model.UploadSession) error {
+	ret := _m.Called(session)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.UploadSession) error); ok {
+		r0 = rf(session)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}

store/storetest/store.go

@@ -35,6 +35,7 @@ type Store struct {
 	EmojiStore                mocks.EmojiStore
 	StatusStore               mocks.StatusStore
 	FileInfoStore             mocks.FileInfoStore
+	UploadSessionStore        mocks.UploadSessionStore
 	ReactionStore             mocks.ReactionStore
 	JobStore                  mocks.JobStore
 	UserAccessTokenStore      mocks.UserAccessTokenStore
@@ -71,6 +72,7 @@ func (s *Store) Token() store.TokenStore                           { return &s.T
 func (s *Store) Emoji() store.EmojiStore                           { return &s.EmojiStore }
 func (s *Store) Status() store.StatusStore                         { return &s.StatusStore }
 func (s *Store) FileInfo() store.FileInfoStore                     { return &s.FileInfoStore }
+func (s *Store) UploadSession() store.UploadSessionStore           { return &s.UploadSessionStore }
 func (s *Store) Reaction() store.ReactionStore                     { return &s.ReactionStore }
 func (s *Store) Job() store.JobStore                               { return &s.JobStore }
 func (s *Store) UserAccessToken() store.UserAccessTokenStore       { return &s.UserAccessTokenStore }
@@ -121,6 +123,7 @@ func (s *Store) AssertExpectations(t mock.TestingT) bool {
 		&s.EmojiStore,
 		&s.StatusStore,
 		&s.FileInfoStore,
+		&s.UploadSessionStore,
 		&s.ReactionStore,
 		&s.JobStore,
 		&s.UserAccessTokenStore,

store/storetest/upload_session_store.go

@@ -0,0 +1,213 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package storetest
+
+import (
+	"testing"
+	"time"
+
+	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/store"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestUploadSessionStore(t *testing.T, ss store.Store) {
+	t.Run("UploadSessionStoreSaveGet", func(t *testing.T) { testUploadSessionStoreSaveGet(t, ss) })
+	t.Run("UploadSessionStoreUpdate", func(t *testing.T) { testUploadSessionStoreUpdate(t, ss) })
+	t.Run("UploadSessionStoreGetForUser", func(t *testing.T) { testUploadSessionStoreGetForUser(t, ss) })
+	t.Run("UploadSessionStoreDelete", func(t *testing.T) { testUploadSessionStoreDelete(t, ss) })
+}
+
+func testUploadSessionStoreSaveGet(t *testing.T, ss store.Store) {
+	var session *model.UploadSession
+
+	t.Run("saving nil session should fail", func(t *testing.T) {
+		us, err := ss.UploadSession().Save(nil)
+		require.Error(t, err)
+		require.Nil(t, us)
+	})
+
+	t.Run("saving empty session should fail", func(t *testing.T) {
+		session = &model.UploadSession{}
+		us, err := ss.UploadSession().Save(session)
+		require.Error(t, err)
+		require.Nil(t, us)
+	})
+
+	t.Run("saving valid session should succeed", func(t *testing.T) {
+		session = &model.UploadSession{
+			Type:      model.UploadTypeAttachment,
+			UserId:    model.NewId(),
+			ChannelId: model.NewId(),
+			Filename:  "test",
+			FileSize:  1024,
+			Path:      "/tmp/test",
+		}
+		us, err := ss.UploadSession().Save(session)
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.NotEmpty(t, us)
+	})
+
+	t.Run("getting non-existing session should fail", func(t *testing.T) {
+		us, err := ss.UploadSession().Get("fake")
+		require.Error(t, err)
+		require.Nil(t, us)
+	})
+
+	t.Run("getting existing session should succeed", func(t *testing.T) {
+		us, err := ss.UploadSession().Get(session.Id)
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.Equal(t, session, us)
+	})
+}
+
+func testUploadSessionStoreUpdate(t *testing.T, ss store.Store) {
+	session := &model.UploadSession{
+		Type:      model.UploadTypeAttachment,
+		UserId:    model.NewId(),
+		ChannelId: model.NewId(),
+		Filename:  "test",
+		FileSize:  1024,
+		Path:      "/tmp/test",
+	}
+
+	t.Run("updating nil session should fail", func(t *testing.T) {
+		err := ss.UploadSession().Update(nil)
+		require.Error(t, err)
+	})
+
+	t.Run("updating invalid session should fail", func(t *testing.T) {
+		err := ss.UploadSession().Update(&model.UploadSession{})
+		require.Error(t, err)
+	})
+
+	t.Run("updating non-existing session should fail", func(t *testing.T) {
+		err := ss.UploadSession().Update(&model.UploadSession{})
+		require.Error(t, err)
+	})
+
+	t.Run("updating existing session should succeed", func(t *testing.T) {
+		us, err := ss.UploadSession().Save(session)
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.NotEmpty(t, us)
+
+		us.FileOffset = 512
+		err = ss.UploadSession().Update(us)
+		require.NoError(t, err)
+
+		updated, err := ss.UploadSession().Get(us.Id)
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.Equal(t, us, updated)
+	})
+}
+
+func testUploadSessionStoreGetForUser(t *testing.T, ss store.Store) {
+	userId := model.NewId()
+
+	sessions := []*model.UploadSession{
+		{
+			Type:      model.UploadTypeAttachment,
+			UserId:    userId,
+			ChannelId: model.NewId(),
+			Filename:  "test0",
+			FileSize:  1024,
+			Path:      "/tmp/test0",
+		},
+		{
+			Type:      model.UploadTypeAttachment,
+			UserId:    model.NewId(),
+			ChannelId: model.NewId(),
+			Filename:  "test1",
+			FileSize:  1024,
+			Path:      "/tmp/test1",
+		},
+		{
+			Type:      model.UploadTypeAttachment,
+			UserId:    userId,
+			ChannelId: model.NewId(),
+			Filename:  "test2",
+			FileSize:  1024,
+			Path:      "/tmp/test2",
+		},
+		{
+			Type:      model.UploadTypeAttachment,
+			UserId:    userId,
+			ChannelId: model.NewId(),
+			Filename:  "test3",
+			FileSize:  1024,
+			Path:      "/tmp/test3",
+		},
+	}
+
+	t.Run("getting invalid userId should fail", func(t *testing.T) {
+		us, err := ss.UploadSession().GetForUser("invalidId")
+		require.Error(t, err)
+		require.Nil(t, us)
+	})
+
+	t.Run("should return no sessions", func(t *testing.T) {
+		us, err := ss.UploadSession().GetForUser(userId)
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.Empty(t, us)
+	})
+
+	for i := 0; i < len(sessions); i++ {
+		us, err := ss.UploadSession().Save(sessions[i])
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.NotEmpty(t, us)
+		// We need this to make sure the ordering is consistent.
+		time.Sleep(1 * time.Millisecond)
+	}
+
+	t.Run("should return existing sessions", func(t *testing.T) {
+		us, err := ss.UploadSession().GetForUser(userId)
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.NotEmpty(t, us)
+		require.Len(t, us, 3)
+
+		require.Equal(t, sessions[0], us[0])
+		require.Equal(t, sessions[2], us[1])
+		require.Equal(t, sessions[3], us[2])
+	})
+}
+
+func testUploadSessionStoreDelete(t *testing.T, ss store.Store) {
+	session := &model.UploadSession{
+		Id:        model.NewId(),
+		Type:      model.UploadTypeAttachment,
+		UserId:    model.NewId(),
+		ChannelId: model.NewId(),
+		Filename:  "test",
+		FileSize:  1024,
+		Path:      "/tmp/test",
+	}
+
+	t.Run("deleting invalid id should fail", func(t *testing.T) {
+		err := ss.UploadSession().Delete("invalidId")
+		require.Error(t, err)
+	})
+
+	t.Run("deleting existing session should succeed", func(t *testing.T) {
+		us, err := ss.UploadSession().Save(session)
+		require.NoError(t, err)
+		require.NotNil(t, us)
+		require.NotEmpty(t, us)
+
+		err = ss.UploadSession().Delete(session.Id)
+		require.NoError(t, err)
+
+		us, err = ss.UploadSession().Get(us.Id)
+		require.Error(t, err)
+		require.Nil(t, us)
+		require.IsType(t, &store.ErrNotFound{}, err)
+	})
+}

store/timerlayer/timerlayer.go

@@ -45,6 +45,7 @@ type TimerLayer struct {
 	TeamStore                 store.TeamStore
 	TermsOfServiceStore       store.TermsOfServiceStore
 	TokenStore                store.TokenStore
+	UploadSessionStore        store.UploadSessionStore
 	UserStore                 store.UserStore
 	UserAccessTokenStore      store.UserAccessTokenStore
 	UserTermsOfServiceStore   store.UserTermsOfServiceStore
@@ -159,6 +160,10 @@ func (s *TimerLayer) Token() store.TokenStore {
 	return s.TokenStore
 }
 
+func (s *TimerLayer) UploadSession() store.UploadSessionStore {
+	return s.UploadSessionStore
+}
+
 func (s *TimerLayer) User() store.UserStore {
 	return s.UserStore
 }
@@ -310,6 +315,11 @@ type TimerLayerTokenStore struct {
 	Root *TimerLayer
 }
 
+type TimerLayerUploadSessionStore struct {
+	store.UploadSessionStore
+	Root *TimerLayer
+}
+
 type TimerLayerUserStore struct {
 	store.UserStore
 	Root *TimerLayer
@@ -6825,6 +6835,86 @@ func (s *TimerLayerTokenStore) Save(recovery *model.Token) error {
 	return err
 }
 
+func (s *TimerLayerUploadSessionStore) Delete(id string) error {
+	start := timemodule.Now()
+
+	err := s.UploadSessionStore.Delete(id)
+
+	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Delete", success, elapsed)
+	}
+	return err
+}
+
+func (s *TimerLayerUploadSessionStore) Get(id string) (*model.UploadSession, error) {
+	start := timemodule.Now()
+
+	result, err := s.UploadSessionStore.Get(id)
+
+	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Get", success, elapsed)
+	}
+	return result, err
+}
+
+func (s *TimerLayerUploadSessionStore) GetForUser(userId string) ([]*model.UploadSession, error) {
+	start := timemodule.Now()
+
+	result, err := s.UploadSessionStore.GetForUser(userId)
+
+	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.GetForUser", success, elapsed)
+	}
+	return result, err
+}
+
+func (s *TimerLayerUploadSessionStore) Save(session *model.UploadSession) (*model.UploadSession, error) {
+	start := timemodule.Now()
+
+	result, err := s.UploadSessionStore.Save(session)
+
+	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Save", success, elapsed)
+	}
+	return result, err
+}
+
+func (s *TimerLayerUploadSessionStore) Update(session *model.UploadSession) error {
+	start := timemodule.Now()
+
+	err := s.UploadSessionStore.Update(session)
+
+	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("UploadSessionStore.Update", success, elapsed)
+	}
+	return err
+}
+
 func (s *TimerLayerUserStore) AnalyticsActiveCount(time int64, options model.UserCountOptions) (int64, *model.AppError) {
 	start := timemodule.Now()
 
@@ -8588,6 +8678,7 @@ func New(childStore store.Store, metrics einterfaces.MetricsInterface) *TimerLay
 	newStore.TeamStore = &TimerLayerTeamStore{TeamStore: childStore.Team(), Root: &newStore}
 	newStore.TermsOfServiceStore = &TimerLayerTermsOfServiceStore{TermsOfServiceStore: childStore.TermsOfService(), Root: &newStore}
 	newStore.TokenStore = &TimerLayerTokenStore{TokenStore: childStore.Token(), Root: &newStore}
+	newStore.UploadSessionStore = &TimerLayerUploadSessionStore{UploadSessionStore: childStore.UploadSession(), Root: &newStore}
 	newStore.UserStore = &TimerLayerUserStore{UserStore: childStore.User(), Root: &newStore}
 	newStore.UserAccessTokenStore = &TimerLayerUserAccessTokenStore{UserAccessTokenStore: childStore.UserAccessToken(), Root: &newStore}
 	newStore.UserTermsOfServiceStore = &TimerLayerUserTermsOfServiceStore{UserTermsOfServiceStore: childStore.UserTermsOfService(), Root: &newStore}