[MM-8497] Ability to set Do Not Disturb for a specified period of time (#17680)

* Revert "Revert "[MM-8497] Ability to set Do Not Disturb for a specified period of time (#16067)" (#17657)" This reverts commit ff383990f8. * add debug log for recurring function * add feature flag for dnd timed status * refactoring changes Co-authored-by: Mattermod <mattermod@users.noreply.github.com>
2021-06-17 00:08:26 +05:30
--- a/store/opentracinglayer/opentracinglayer.go
+++ b/store/opentracinglayer/opentracinglayer.go
@@ -7634,6 +7634,24 @@ func (s *OpenTracingLayerStatusStore) SaveOrUpdate(status *model.Status) error {
 	return err
 }

+func (s *OpenTracingLayerStatusStore) UpdateExpiredDNDStatuses() ([]*model.Status, error) {
+	origCtx := s.Root.Store.Context()
+	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "StatusStore.UpdateExpiredDNDStatuses")
+	s.Root.Store.SetContext(newCtx)
+	defer func() {
+		s.Root.Store.SetContext(origCtx)
+	}()
+
+	defer span.Finish()
+	result, err := s.StatusStore.UpdateExpiredDNDStatuses()
+	if err != nil {
+		span.LogFields(spanlog.Error(err))
+		ext.Error.Set(span, true)
+	}
+
+	return result, err
+}
+
 func (s *OpenTracingLayerStatusStore) UpdateLastActivityAt(userID string, lastActivityAt int64) error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "StatusStore.UpdateLastActivityAt")
--- a/store/retrylayer/retrylayer.go
+++ b/store/retrylayer/retrylayer.go
@@ -8296,6 +8296,26 @@ func (s *RetryLayerStatusStore) SaveOrUpdate(status *model.Status) error {

 }

+func (s *RetryLayerStatusStore) UpdateExpiredDNDStatuses() ([]*model.Status, error) {
+
+	tries := 0
+	for {
+		result, err := s.StatusStore.UpdateExpiredDNDStatuses()
+		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 *RetryLayerStatusStore) UpdateLastActivityAt(userID string, lastActivityAt int64) error {

 	tries := 0
--- a/store/sqlstore/status_store.go
+++ b/store/sqlstore/status_store.go
@@ -7,10 +7,12 @@ import (
 	"database/sql"
 	"fmt"
 	"strings"
+	"time"

 	sq "github.com/Masterminds/squirrel"
 	"github.com/pkg/errors"

+	"github.com/mattermost/gorp"
 	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/mattermost/mattermost-server/v5/store"
 )
@@ -27,6 +29,7 @@ func newSqlStatusStore(sqlStore *SqlStore) store.StatusStore {
 		table.ColMap("UserId").SetMaxSize(26)
 		table.ColMap("Status").SetMaxSize(32)
 		table.ColMap("ActiveChannel").SetMaxSize(26)
+		table.ColMap("PrevStatus").SetMaxSize(32)
 	}

 	return s
@@ -98,6 +101,119 @@ func (s SqlStatusStore) GetByIds(userIds []string) ([]*model.Status, error) {
 	return statuses, nil
 }

+// MySQL doesn't have support for RETURNING clause, so we use a transaction to get the updated rows.
+func (s SqlStatusStore) updateExpiredStatuses(t *gorp.Transaction) ([]*model.Status, error) {
+	var statuses []*model.Status
+	currUnixTime := time.Now().UTC().Unix()
+	selectQuery, selectParams, err := s.getQueryBuilder().
+		Select("*").
+		From("Status").
+		Where(
+			sq.And{
+				sq.Eq{"Status": model.STATUS_DND},
+				sq.Gt{"DNDEndTime": 0},
+				sq.LtOrEq{"DNDEndTime": currUnixTime},
+			},
+		).ToSql()
+	if err != nil {
+		return nil, errors.Wrap(err, "status_tosql")
+	}
+	_, err = t.Select(&statuses, selectQuery, selectParams...)
+	if err != nil {
+		return nil, errors.Wrap(err, "updateExpiredStatusesT: failed to get expired dnd statuses")
+	}
+	updateQuery, args, err := s.getQueryBuilder().
+		Update("Status").
+		Where(
+			sq.And{
+				sq.Eq{"Status": model.STATUS_DND},
+				sq.Gt{"DNDEndTime": 0},
+				sq.LtOrEq{"DNDEndTime": currUnixTime},
+			},
+		).
+		Set("Status", sq.Expr("PrevStatus")).
+		Set("PrevStatus", model.STATUS_DND).
+		Set("DNDEndTime", 0).
+		Set("Manual", false).
+		ToSql()
+
+	if err != nil {
+		return nil, errors.Wrap(err, "status_tosql")
+	}
+
+	if _, err := t.Exec(updateQuery, args...); err != nil {
+		return nil, errors.Wrapf(err, "updateExpiredStatusesT: failed to update statuses")
+	}
+
+	return statuses, nil
+}
+
+func (s SqlStatusStore) UpdateExpiredDNDStatuses() ([]*model.Status, error) {
+	if s.DriverName() == model.DATABASE_DRIVER_MYSQL {
+		transaction, err := s.GetMaster().Begin()
+		if err != nil {
+			return nil, errors.Wrap(err, "UpdateExpiredDNDStatuses: begin_transaction")
+		}
+		defer finalizeTransaction(transaction)
+		statuses, err := s.updateExpiredStatuses(transaction)
+		if err != nil {
+			return nil, errors.Wrap(err, "UpdateExpiredDNDStatuses: updateExpiredDNDStatusesT")
+		}
+		if err := transaction.Commit(); err != nil {
+			return nil, errors.Wrap(err, "UpdateExpiredDNDStatuses: commit_transaction")
+		}
+
+		for _, status := range statuses {
+			status.Status = status.PrevStatus
+			status.PrevStatus = model.STATUS_DND
+			status.DNDEndTime = 0
+			status.Manual = false
+		}
+
+		return statuses, nil
+	}
+
+	queryString, args, err := s.getQueryBuilder().
+		Update("Status").
+		Where(
+			sq.And{
+				sq.Eq{"Status": model.STATUS_DND},
+				sq.Gt{"DNDEndTime": 0},
+				sq.LtOrEq{"DNDEndTime": time.Now().UTC().Unix()},
+			},
+		).
+		Set("Status", sq.Expr("PrevStatus")).
+		Set("PrevStatus", model.STATUS_DND).
+		Set("DNDEndTime", 0).
+		Set("Manual", false).
+		Suffix("RETURNING *").
+		ToSql()
+
+	if err != nil {
+		return nil, errors.Wrap(err, "status_tosql")
+	}
+
+	rows, err := s.GetMaster().Query(queryString, args...)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to find Statuses")
+	}
+	defer rows.Close()
+	var statuses []*model.Status
+	for rows.Next() {
+		var status model.Status
+		if err = rows.Scan(&status.UserId, &status.Status, &status.Manual, &status.LastActivityAt,
+			&status.DNDEndTime, &status.PrevStatus); err != nil {
+			return nil, errors.Wrap(err, "unable to scan from rows")
+		}
+		statuses = append(statuses, &status)
+	}
+	if err = rows.Err(); err != nil {
+		return nil, errors.Wrap(err, "failed while iterating over rows")
+	}
+
+	return statuses, nil
+}
+
 func (s SqlStatusStore) ResetAll() error {
 	if _, err := s.GetMaster().Exec("UPDATE Status SET Status = :Status WHERE Manual = false", map[string]interface{}{"Status": model.STATUS_OFFLINE}); err != nil {
 		return errors.Wrap(err, "failed to update Statuses")
--- a/store/sqlstore/upgrade.go
+++ b/store/sqlstore/upgrade.go
@@ -972,6 +972,7 @@ func upgradeDatabaseToVersion530(sqlStore *SqlStore) {
 		sqlStore.CreateColumnIfNotExistsNoDefault("FileInfo", "Content", "longtext", "text")

 		sqlStore.CreateColumnIfNotExists("SidebarCategories", "Muted", "tinyint(1)", "boolean", "0")
+
 		saveSchemaVersion(sqlStore, Version5300)
 	}
 }
@@ -1087,6 +1088,9 @@ func upgradeDatabaseToVersion536(sqlStore *SqlStore) {
 		sqlStore.CreateColumnIfNotExists("SharedChannelRemotes", "LastPostUpdateAt", "bigint", "bigint", "0")
 		sqlStore.CreateColumnIfNotExists("SharedChannelRemotes", "LastPostId", "VARCHAR(26)", "VARCHAR(26)", "")

+		sqlStore.CreateColumnIfNotExistsNoDefault("Status", "DNDEndTime", "bigint", "bigint")
+		sqlStore.CreateColumnIfNotExistsNoDefault("Status", "PrevStatus", "VARCHAR(32)", "VARCHAR(32)")
+
 		saveSchemaVersion(sqlStore, Version5360)
 	}
 }
--- a/store/store.go
+++ b/store/store.go
@@ -605,6 +605,7 @@ type StatusStore interface {
 	ResetAll() error
 	GetTotalActiveUsersCount() (int64, error)
 	UpdateLastActivityAt(userID string, lastActivityAt int64) error
+	UpdateExpiredDNDStatuses() ([]*model.Status, error)
 }

 type FileInfoStore interface {
--- a/store/storetest/mocks/StatusStore.go
+++ b/store/storetest/mocks/StatusStore.go
@@ -109,6 +109,29 @@ func (_m *StatusStore) SaveOrUpdate(status *model.Status) error {
 	return r0
 }

+// UpdateExpiredDNDStatuses provides a mock function with given fields:
+func (_m *StatusStore) UpdateExpiredDNDStatuses() ([]*model.Status, error) {
+	ret := _m.Called()
+
+	var r0 []*model.Status
+	if rf, ok := ret.Get(0).(func() []*model.Status); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Status)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // UpdateLastActivityAt provides a mock function with given fields: userID, lastActivityAt
 func (_m *StatusStore) UpdateLastActivityAt(userID string, lastActivityAt int64) error {
 	ret := _m.Called(userID, lastActivityAt)
--- a/store/storetest/status_store.go
+++ b/store/storetest/status_store.go
@@ -5,6 +5,7 @@ package storetest

 import (
 	"testing"
+	"time"

 	"github.com/stretchr/testify/require"

@@ -15,6 +16,7 @@ import (
 func TestStatusStore(t *testing.T, ss store.Store) {
 	t.Run("", func(t *testing.T) { testStatusStore(t, ss) })
 	t.Run("ActiveUserCount", func(t *testing.T) { testActiveUserCount(t, ss) })
+	t.Run("UpdateExpiredDNDStatuses", func(t *testing.T) { testUpdateExpiredDNDStatuses(t, ss) })
 }

 func testStatusStore(t *testing.T, ss store.Store) {
@@ -61,3 +63,32 @@ type ByUserId []*model.Status
 func (s ByUserId) Len() int           { return len(s) }
 func (s ByUserId) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
 func (s ByUserId) Less(i, j int) bool { return s[i].UserId < s[j].UserId }
+
+func testUpdateExpiredDNDStatuses(t *testing.T, ss store.Store) {
+	userID := NewTestId()
+
+	status := &model.Status{UserId: userID, Status: model.STATUS_DND, Manual: true,
+		DNDEndTime: time.Now().Add(5 * time.Second).Unix(), PrevStatus: model.STATUS_ONLINE}
+	require.NoError(t, ss.Status().SaveOrUpdate(status))
+
+	time.Sleep(2 * time.Second)
+
+	// after 2 seconds no statuses should be expired
+	statuses, err := ss.Status().UpdateExpiredDNDStatuses()
+	require.NoError(t, err)
+	require.Len(t, statuses, 0)
+
+	time.Sleep(3 * time.Second)
+
+	// after 3 more seconds test status should be updated
+	statuses, err = ss.Status().UpdateExpiredDNDStatuses()
+	require.NoError(t, err)
+	require.Len(t, statuses, 1)
+
+	updatedStatus := *statuses[0]
+	require.Equal(t, updatedStatus.UserId, userID)
+	require.Equal(t, updatedStatus.Status, model.STATUS_ONLINE)
+	require.Equal(t, updatedStatus.DNDEndTime, int64(0))
+	require.Equal(t, updatedStatus.PrevStatus, model.STATUS_DND)
+	require.Equal(t, updatedStatus.Manual, false)
+}
--- a/store/timerlayer/timerlayer.go
+++ b/store/timerlayer/timerlayer.go
@@ -6888,6 +6888,22 @@ func (s *TimerLayerStatusStore) SaveOrUpdate(status *model.Status) error {
 	return err
 }

+func (s *TimerLayerStatusStore) UpdateExpiredDNDStatuses() ([]*model.Status, error) {
+	start := timemodule.Now()
+
+	result, err := s.StatusStore.UpdateExpiredDNDStatuses()
+
+	elapsed := float64(timemodule.Since(start)) / float64(timemodule.Second)
+	if s.Root.Metrics != nil {
+		success := "false"
+		if err == nil {
+			success = "true"
+		}
+		s.Root.Metrics.ObserveStoreMethodDuration("StatusStore.UpdateExpiredDNDStatuses", success, elapsed)
+	}
+	return result, err
+}
+
 func (s *TimerLayerStatusStore) UpdateLastActivityAt(userID string, lastActivityAt int64) error {
 	start := timemodule.Now()