Migrate "Post.GetParentsForExportAfter" to Sync by default #10965 (#11029)

app/export.go

@@ -332,14 +332,12 @@ func (a *App) buildUserNotifyProps(notifyProps model.StringMap) *UserNotifyProps
 func (a *App) ExportAllPosts(writer io.Writer) *model.AppError {
 	afterId := strings.Repeat("0", 26)
 	for {
-		result := <-a.Srv.Store.Post().GetParentsForExportAfter(1000, afterId)
+		posts, err := a.Srv.Store.Post().GetParentsForExportAfter(1000, afterId)
 
-		if result.Err != nil {
+		if err != nil {
-			return result.Err
+			return err
 		}
 
-		posts := result.Data.([]*model.PostForExport)
-
 		if len(posts) == 0 {
 			break
 		}

store/sqlstore/post_store.go

@@ -1263,10 +1263,9 @@ func (s *SqlPostStore) GetMaxPostSize() int {
 	return s.maxPostSizeCached
 }
 
-func (s *SqlPostStore) GetParentsForExportAfter(limit int, afterId string) store.StoreChannel {
+func (s *SqlPostStore) GetParentsForExportAfter(limit int, afterId string) ([]*model.PostForExport, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	var posts []*model.PostForExport
-		var posts []*model.PostForExport
+	_, err := s.GetSearchReplica().Select(&posts, `
-		_, err1 := s.GetSearchReplica().Select(&posts, `
                 SELECT
                     p1.*,
                     Users.Username as Username,
@@ -1290,14 +1289,13 @@ func (s *SqlPostStore) GetParentsForExportAfter(limit int, afterId string) store
                     p1.Id
                 LIMIT
                     :Limit`,
-			map[string]interface{}{"Limit": limit, "AfterId": afterId})
+		map[string]interface{}{"Limit": limit, "AfterId": afterId})
 
-		if err1 != nil {
+	if err != nil {
-			result.Err = model.NewAppError("SqlPostStore.GetAllAfterForExport", "store.sql_post.get_posts.app_error", nil, err1.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("SqlPostStore.GetAllAfterForExport", "store.sql_post.get_posts.app_error",
-		} else {
+			nil, err.Error(), http.StatusInternalServerError)
-			result.Data = posts
+	}
-		}
+	return posts, nil
-	})
 }
 
 func (s *SqlPostStore) GetRepliesForExport(parentId string) store.StoreChannel {

store/store.go

@@ -238,7 +238,7 @@ type PostStore interface {
 	PermanentDeleteBatch(endTime int64, limit int64) StoreChannel
 	GetOldest() StoreChannel
 	GetMaxPostSize() int
-	GetParentsForExportAfter(limit int, afterId string) StoreChannel
+	GetParentsForExportAfter(limit int, afterId string) ([]*model.PostForExport, *model.AppError)
 	GetRepliesForExport(parentId string) StoreChannel
 	GetDirectPostParentsForExportAfter(limit int, afterId string) ([]*model.DirectPostForExport, *model.AppError)
 }

store/storetest/mocks/PostStore.go

@@ -252,19 +252,28 @@ func (_m *PostStore) GetOldest() store.StoreChannel {
 }
 
 // GetParentsForExportAfter provides a mock function with given fields: limit, afterId
-func (_m *PostStore) GetParentsForExportAfter(limit int, afterId string) store.StoreChannel {
+func (_m *PostStore) GetParentsForExportAfter(limit int, afterId string) ([]*model.PostForExport, *model.AppError) {
 	ret := _m.Called(limit, afterId)
 
-	var r0 store.StoreChannel
+	var r0 []*model.PostForExport
-	if rf, ok := ret.Get(0).(func(int, string) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(int, string) []*model.PostForExport); ok {
 		r0 = rf(limit, afterId)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).([]*model.PostForExport)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(int, string) *model.AppError); ok {
+		r1 = rf(limit, afterId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // GetPosts provides a mock function with given fields: channelId, offset, limit, allowFromCache

store/storetest/post_store.go

@@ -2114,12 +2114,11 @@ func testPostStoreGetParentsForExportAfter(t *testing.T, ss store.Store) {
 	p1.CreateAt = 1000
 	p1 = (<-ss.Post().Save(p1)).Data.(*model.Post)
 
-	r1 := <-ss.Post().GetParentsForExportAfter(10000, strings.Repeat("0", 26))
+	posts, err := ss.Post().GetParentsForExportAfter(10000, strings.Repeat("0", 26))
-	assert.Nil(t, r1.Err)
+	assert.Nil(t, err)
-	d1 := r1.Data.([]*model.PostForExport)
 
 	found := false
-	for _, p := range d1 {
+	for _, p := range posts {
 		if p.Id == p1.Id {
 			found = true
 			assert.Equal(t, p.Id, p1.Id)