Scheduled post

go.mod

@@ -32,7 +32,7 @@ require (
 	github.com/gliderlabs/ssh v0.1.1
 	github.com/grafana/alloy/syntax v0.1.0
 	github.com/graph-gophers/graphql-go v1.5.1-0.20230110080634-edea822f558a
-	github.com/mattermost/mattermost/server/public v0.1.8-0.20241015185928-63c97f5a6d8f
+	github.com/mattermost/mattermost/server/public v0.1.9
 	github.com/mattermost/mattermost/server/v8 v8.0.0-20241015185928-63c97f5a6d8f
 	github.com/opensearch-project/opensearch-go/v4 v4.1.0
 	github.com/pelletier/go-toml/v2 v2.2.2

go.sum

@@ -272,6 +272,8 @@ github.com/mattermost/logr/v2 v2.0.21 h1:CMHsP+nrbRlEC4g7BwOk1GAnMtHkniFhlSQPXy5
 github.com/mattermost/logr/v2 v2.0.21/go.mod h1:kZkB/zqKL9e+RY5gB3vGpsyenC+TpuiOenjMkvJJbzc=
 github.com/mattermost/mattermost/server/public v0.1.8-0.20241015185928-63c97f5a6d8f h1:NUAf56HZHFLayAyCqHxeVLmxJUN9xw3Qxc9m3ghy+Xw=
 github.com/mattermost/mattermost/server/public v0.1.8-0.20241015185928-63c97f5a6d8f/go.mod h1:SkTKbMul91Rq0v2dIxe8mqzUOY+3KwlwwLmAlxDfGCk=
+github.com/mattermost/mattermost/server/public v0.1.9 h1:l/OKPRVuFeqL0yqRVC/JpveG5sLNKcT9llxqMkO9e+s=
+github.com/mattermost/mattermost/server/public v0.1.9/go.mod h1:SkTKbMul91Rq0v2dIxe8mqzUOY+3KwlwwLmAlxDfGCk=
 github.com/mattermost/mattermost/server/v8 v8.0.0-20241015185928-63c97f5a6d8f h1:h4T89Qkb3kddGnRN7xQAuB+fDaL3OgUgc5YPmssmzj8=
 github.com/mattermost/mattermost/server/v8 v8.0.0-20241015185928-63c97f5a6d8f/go.mod h1:zwMZYGK4/xDy/kyepVBqXhM58YMTCRlanv/uKrZzJdw=
 github.com/mattermost/morph v1.1.0 h1:Q9vrJbeM3s2jfweGheq12EFIzdNp9a/6IovcbvOQ6Cw=

loadtest/control/actions.go

@@ -1034,6 +1034,15 @@ func DraftsEnabled(u user.User) (bool, UserActionResponse) {
 
 func ChannelBookmarkEnabled(u user.User) (bool, UserActionResponse) {
 	allow := u.Store().FeatureFlags()["ChannelBookmarks"]
+	return allow, UserActionResponse{}
+}
+
+func ScheduledPostsEnabled(u user.User) (bool, UserActionResponse) {
+	allow, err := strconv.ParseBool(u.Store().ClientConfig()["ScheduledPosts"])
+	if err != nil {
+		fmt.Println("Error parsing ScheduledPosts config", err)
+		return false, UserActionResponse{Err: NewUserError(err)}
+	}
 
 	return allow, UserActionResponse{}
 }

loadtest/control/simulcontroller/actions.go

@@ -293,6 +293,10 @@ func loadTeam(u user.User, team *model.Team, gqlEnabled bool) control.UserAction
 		return control.UserActionResponse{Err: control.NewUserError(err)}
 	}
 
+	if err := u.GetTeamScheduledPosts(team.Id); err != nil {
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
 	return control.UserActionResponse{Info: fmt.Sprintf("loaded team %s", team.Id)}
 }
 

loadtest/control/simulcontroller/controller.go

@@ -288,6 +288,30 @@ func getActionList(c *SimulController) []userAction {
 			frequency:        0.0001, // https://mattermost.atlassian.net/browse/MM-61131
 			minServerVersion: semver.MustParse("10.0.0"),
 		},
+		{
+			name:             "CreateScheduledPost",
+			run:              c.createScheduledPost,
+			frequency:        0.2,
+			minServerVersion: semver.MustParse("10.3.0"),
+		},
+		{
+			name:             "UpdateScheduledPost",
+			run:              c.updateScheduledPost,
+			frequency:        0.1,
+			minServerVersion: semver.MustParse("10.3.0"),
+		},
+		{
+			name:             "DeleteScheduledPost",
+			run:              c.deleteScheduledPost,
+			frequency:        0.1,
+			minServerVersion: semver.MustParse("10.3.0"),
+		},
+		{
+			name:             "SendScheduledPost",
+			run:              c.sendScheduledPost,
+			frequency:        0.1,
+			minServerVersion: semver.MustParse("10.3.0"),
+		},
 		// All actions are required to contain a valid minServerVersion:
 		//   - If the action is present in server versions equal or older than
 		//     control.MinSupportedVersion, use control.MinSupportedVersion.

loadtest/control/simulcontroller/scheduled_posts.go

@@ -0,0 +1,184 @@
+package simulcontroller
+
+import (
+	"fmt"
+	"github.com/mattermost/mattermost-load-test-ng/loadtest"
+	"github.com/mattermost/mattermost-load-test-ng/loadtest/control"
+	"github.com/mattermost/mattermost-load-test-ng/loadtest/user"
+	"github.com/mattermost/mattermost/server/public/model"
+	"math/rand"
+)
+
+func (c *SimulController) createScheduledPost(u user.User) control.UserActionResponse {
+	if ok, resp := control.ScheduledPostsEnabled(u); resp.Err != nil {
+		fmt.Println("createScheduledPost: ScheduledPostsEnabled error", resp.Err)
+		return resp
+	} else if !ok {
+		fmt.Println("createScheduledPost: ScheduledPosts not enabled")
+		return control.UserActionResponse{Info: "scheduled posts not enabled"}
+	}
+
+	channel, err := u.Store().CurrentChannel()
+	if err != nil {
+		fmt.Println("createScheduledPost: CurrentChannel error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	fmt.Println("createScheduledPost: got the channel", channel.Id)
+	var rootId = ""
+	if rand.Float64() < 0.25 {
+		post, err := u.Store().RandomPostForChannel(channel.Id)
+		if err == nil {
+			if post.RootId != "" {
+				rootId = post.RootId
+			} else {
+				rootId = post.Id
+			}
+		}
+	}
+
+	if err := sendTypingEventIfEnabled(u, channel.Id); err != nil {
+		fmt.Println("createScheduledPost: sendTypingEventIfEnabled error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	message, err := createMessage(u, channel, false)
+	if err != nil {
+		fmt.Println("createScheduledPost: createMessage error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	scheduledPost := &model.ScheduledPost{
+		Draft: model.Draft{
+			Message:   message,
+			ChannelId: channel.Id,
+			RootId:    rootId,
+			CreateAt:  model.GetMillis(),
+		},
+		ScheduledAt: loadtest.RandomFutureTime(17_28_00_000, 10),
+	}
+
+	if rand.Float64() < 0.02 {
+		if err := control.AttachFilesToDraft(u, &scheduledPost.Draft); err != nil {
+			fmt.Println("createScheduledPost: AttachFilesToDraft error", err)
+			return control.UserActionResponse{Err: control.NewUserError(err)}
+		}
+	}
+
+	if err := u.CreateScheduledPost(channel.TeamId, scheduledPost); err != nil {
+		fmt.Println("createScheduledPost: CreateScheduledPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	return control.UserActionResponse{Info: fmt.Sprintf("scheduled post created in channel id %v", channel.Id)}
+}
+
+func (c *SimulController) updateScheduledPost(u user.User) control.UserActionResponse {
+	if ok, resp := control.ScheduledPostsEnabled(u); resp.Err != nil {
+		fmt.Println("updateScheduledPost: ScheduledPostsEnabled error", resp.Err)
+		return resp
+	} else if !ok {
+		fmt.Println("updateScheduledPost: ScheduledPosts not enabled")
+		return control.UserActionResponse{Info: "scheduled posts not enabled"}
+	}
+
+	scheduledPost, err := u.Store().GetRandomScheduledPost()
+	if err != nil {
+		fmt.Println("updateScheduledPost: GetRandomScheduledPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+	if scheduledPost == nil {
+		fmt.Println("updateScheduledPost: no scheduled posts found")
+		return control.UserActionResponse{Info: "no scheduled posts found"}
+	}
+
+	channel, err := u.Store().CurrentChannel()
+	if err != nil {
+		fmt.Println("updateScheduledPost: CurrentChannel error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	message, err := createMessage(u, channel, false)
+	if err != nil {
+		fmt.Println("updateScheduledPost: createMessage error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	scheduledPost.Message = message
+	scheduledPost.ScheduledAt = loadtest.RandomFutureTime(17_28_00_000, 10)
+
+	if err := u.UpdateScheduledPost(channel.TeamId, scheduledPost); err != nil {
+		fmt.Println("updateScheduledPost: UpdateScheduledPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	return control.UserActionResponse{Info: fmt.Sprintf("scheduled post updated in channel id %v", channel.Id)}
+}
+
+func (c *SimulController) deleteScheduledPost(u user.User) control.UserActionResponse {
+	if ok, resp := control.ScheduledPostsEnabled(u); resp.Err != nil {
+		fmt.Println("deleteScheduledPost: ScheduledPostsEnabled error", resp.Err)
+		return resp
+	} else if !ok {
+		fmt.Println("deleteScheduledPost: ScheduledPosts not enabled")
+		return control.UserActionResponse{Info: "scheduled posts not enabled"}
+	}
+
+	scheduledPost, err := u.Store().GetRandomScheduledPost()
+	if err != nil {
+		fmt.Println("deleteScheduledPost: GetRandomScheduledPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+	if scheduledPost == nil {
+		fmt.Println("deleteScheduledPost: no scheduled posts found")
+		return control.UserActionResponse{Info: "no scheduled posts found"}
+	}
+
+	if err := u.DeleteScheduledPost(scheduledPost.Id); err != nil {
+		fmt.Println("deleteScheduledPost: DeleteScheduledPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	u.Store().DeleteScheduledPost(scheduledPost.Id)
+	return control.UserActionResponse{Info: fmt.Sprintf("scheduled post deleted with id %v", scheduledPost.Id)}
+}
+
+func (c *SimulController) sendScheduledPost(u user.User) control.UserActionResponse {
+	if ok, resp := control.ScheduledPostsEnabled(u); resp.Err != nil {
+		fmt.Println("sendScheduledPost: ScheduledPostsEnabled error", resp.Err)
+		return resp
+	} else if !ok {
+		fmt.Println("sendScheduledPost: ScheduledPosts not enabled")
+		return control.UserActionResponse{Info: "scheduled posts not enabled"}
+	}
+
+	scheduledPost, err := u.Store().GetRandomScheduledPost()
+	if err != nil {
+		fmt.Println("sendScheduledPost: GetRandomScheduledPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+	if scheduledPost == nil {
+		fmt.Println("sendScheduledPost: no scheduled posts found")
+		return control.UserActionResponse{Info: "no scheduled posts found"}
+	}
+
+	post, err := scheduledPost.ToPost()
+	if err != nil {
+		fmt.Println("sendScheduledPost: ToPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	if _, err := u.CreatePost(post); err != nil {
+		fmt.Println("sendScheduledPost: CreatePost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	if err := u.DeleteScheduledPost(scheduledPost.Id); err != nil {
+		fmt.Println("sendScheduledPost: DeleteScheduledPost error", err)
+		return control.UserActionResponse{Err: control.NewUserError(err)}
+	}
+
+	u.Store().DeleteScheduledPost(scheduledPost.Id)
+
+	return control.UserActionResponse{Info: fmt.Sprintf("scheduled post sent with id %v", scheduledPost.Id)}
+}

loadtest/store/memstore/random.go

@@ -6,6 +6,7 @@ package memstore
 import (
 	"errors"
 	"math/rand"
+	"time"
 
 	"github.com/mattermost/mattermost-load-test-ng/loadtest/store"
 	"github.com/mattermost/mattermost/server/public/model"
@@ -448,3 +449,70 @@ func (s *MemStore) RandomDraftForTeam(teamId string) (string, error) {
 
 	return draftIDs[rand.Intn(len(draftIDs))], nil
 }
+
+func (s *MemStore) GetRandomScheduledPost() (*model.ScheduledPost, error) {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+
+	// Seed the random generator
+	rand.Seed(time.Now().UnixNano())
+
+	// Check if scheduledPosts is empty
+	if len(s.scheduledPosts) == 0 {
+		return nil, errors.New("no scheduled posts available")
+	}
+
+	// Pick a random index for the outer map
+	randomOuterIndex := rand.Intn(len(s.scheduledPosts))
+	var selectedInnerMap map[string]*model.ScheduledPost
+	outerIndex := 0
+	for _, innerMap := range s.scheduledPosts {
+		if outerIndex == randomOuterIndex {
+			selectedInnerMap = innerMap
+			break
+		}
+		outerIndex++
+	}
+
+	// Check if the selected inner map is empty
+	if len(selectedInnerMap) == 0 {
+		return nil, errors.New("no posts available in selected category")
+	}
+
+	// Pick a random index for the inner map
+	randomInnerIndex := rand.Intn(len(selectedInnerMap))
+	var selectedPost *model.ScheduledPost
+	innerIndex := 0
+	for _, post := range selectedInnerMap {
+		if innerIndex == randomInnerIndex {
+			selectedPost = post
+			break
+		}
+		innerIndex++
+	}
+
+	return selectedPost, nil
+}
+
+func (s *MemStore) DeleteScheduledPost(scheduledPostID string) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	for teamId := range s.scheduledPosts {
+		if _, ok := s.scheduledPosts[teamId][scheduledPostID]; ok {
+			delete(s.scheduledPosts[teamId], scheduledPostID)
+			break
+		}
+	}
+}
+
+func (s *MemStore) UpdateScheduledPost(teamId string, scheduledPost *model.ScheduledPost) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if _, ok := s.scheduledPosts[teamId]; !ok {
+		s.scheduledPosts[teamId] = make(map[string]*model.ScheduledPost)
+	}
+
+	s.scheduledPosts[teamId][scheduledPost.Id] = scheduledPost
+}

loadtest/store/memstore/store.go

@@ -52,6 +52,7 @@ type MemStore struct {
 	featureFlags        map[string]bool
 	report              *model.PerformanceReport
 	channelBookmarks    map[string]*model.ChannelBookmarkWithFileInfo
+	scheduledPosts      map[string]map[string]*model.ScheduledPost
 }
 
 // New returns a new instance of MemStore with the given config.
@@ -1356,6 +1357,25 @@ func (s *MemStore) DeleteChannelBookmark(bookmarkId string) error {
 	}
 
 	delete(s.channelBookmarks, bookmarkId)
+	return nil
+}
+
+func (s *MemStore) SetScheduledPost(teamId, id string, scheduledPost *model.ScheduledPost) error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if scheduledPost == nil {
+		return errors.New("memstore: scheduled post should not be nil")
+	}
+
+	if s.scheduledPosts == nil {
+		s.scheduledPosts = map[string]map[string]*model.ScheduledPost{}
+	}
+
+	if s.scheduledPosts[teamId] == nil {
+		s.scheduledPosts[teamId] = map[string]*model.ScheduledPost{}
+	}
 
+	s.scheduledPosts[teamId][id] = scheduledPost
 	return nil
 }

loadtest/store/store.go

@@ -165,6 +165,10 @@ type UserStore interface {
 
 	// DeleteChannelBookmark deletes a given bookmarkId.
 	DeleteChannelBookmark(bookmarkId string) error
+
+	GetRandomScheduledPost() (*model.ScheduledPost, error)
+	DeleteScheduledPost(scheduledPostID string)
+	UpdateScheduledPost(teamId string, scheduledPost *model.ScheduledPost)
 }
 
 // MutableUserStore is a super-set of UserStore which, apart from providing
@@ -200,6 +204,10 @@ type MutableUserStore interface {
 	// SetDrafts stores the given drafts.
 	SetDrafts(teamId string, drafts []*model.Draft) error
 
+	// scheduled posts
+	SetScheduledPost(teamId, id string, scheduledPost *model.ScheduledPost) error
+	GetRandomScheduledPost() (*model.ScheduledPost, error)
+
 	// posts
 	// SetPost stores the given post.
 	SetPost(post *model.Post) error