Migrating cluster discovery store to sync by default (#10665)

* Migrating cluster discovery store to sync by default

* Addressing PR review comments

app/cluster_discovery.go

@@ -32,21 +32,24 @@ func (a *App) NewClusterDiscoveryService() *ClusterDiscoveryService {
 }
 
 func (me *ClusterDiscoveryService) Start() {
+	err := me.app.Srv.Store.ClusterDiscovery().Cleanup()
+	if err != nil {
+		mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to cleanup the outdated cluster discovery information err=%v", err))
+	}
 
-	<-me.app.Srv.Store.ClusterDiscovery().Cleanup()
+	exists, err := me.app.Srv.Store.ClusterDiscovery().Exists(&me.ClusterDiscovery)
-
+	if err != nil {
-	if cresult := <-me.app.Srv.Store.ClusterDiscovery().Exists(&me.ClusterDiscovery); cresult.Err != nil {
+		mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to check if row exists for %v with err=%v", me.ClusterDiscovery.ToJson(), err))
-		mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to check if row exists for %v with err=%v", me.ClusterDiscovery.ToJson(), cresult.Err))
 	} else {
-		if cresult.Data.(bool) {
+		if exists {
-			if u := <-me.app.Srv.Store.ClusterDiscovery().Delete(&me.ClusterDiscovery); u.Err != nil {
+			if _, err := me.app.Srv.Store.ClusterDiscovery().Delete(&me.ClusterDiscovery); err != nil {
-				mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to start clean for %v with err=%v", me.ClusterDiscovery.ToJson(), u.Err))
+				mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to start clean for %v with err=%v", me.ClusterDiscovery.ToJson(), err))
 			}
 		}
 	}
 
-	if result := <-me.app.Srv.Store.ClusterDiscovery().Save(&me.ClusterDiscovery); result.Err != nil {
+	if err := me.app.Srv.Store.ClusterDiscovery().Save(&me.ClusterDiscovery); err != nil {
-		mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to save for %v with err=%v", me.ClusterDiscovery.ToJson(), result.Err))
+		mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to save for %v with err=%v", me.ClusterDiscovery.ToJson(), err))
 		return
 	}
 
@@ -55,8 +58,8 @@ func (me *ClusterDiscoveryService) Start() {
 		ticker := time.NewTicker(DISCOVERY_SERVICE_WRITE_PING)
 		defer func() {
 			ticker.Stop()
-			if u := <-me.app.Srv.Store.ClusterDiscovery().Delete(&me.ClusterDiscovery); u.Err != nil {
+			if _, err := me.app.Srv.Store.ClusterDiscovery().Delete(&me.ClusterDiscovery); err != nil {
-				mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to cleanup for %v with err=%v", me.ClusterDiscovery.ToJson(), u.Err))
+				mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to cleanup for %v with err=%v", me.ClusterDiscovery.ToJson(), err))
 			}
 			mlog.Debug(fmt.Sprintf("ClusterDiscoveryService ping writer stopped for %v", me.ClusterDiscovery.ToJson()))
 		}()
@@ -64,8 +67,8 @@ func (me *ClusterDiscoveryService) Start() {
 		for {
 			select {
 			case <-ticker.C:
-				if u := <-me.app.Srv.Store.ClusterDiscovery().SetLastPingAt(&me.ClusterDiscovery); u.Err != nil {
+				if err := me.app.Srv.Store.ClusterDiscovery().SetLastPingAt(&me.ClusterDiscovery); err != nil {
-					mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to write ping for %v with err=%v", me.ClusterDiscovery.ToJson(), u.Err))
+					mlog.Error(fmt.Sprintf("ClusterDiscoveryService failed to write ping for %v with err=%v", me.ClusterDiscovery.ToJson(), err))
 				}
 			case <-me.stop:
 				return

store/sqlstore/cluster_discovery_store.go

@@ -28,145 +28,133 @@ func NewSqlClusterDiscoveryStore(sqlStore SqlStore) store.ClusterDiscoveryStore
 	return s
 }
 
-func (s sqlClusterDiscoveryStore) Save(ClusterDiscovery *model.ClusterDiscovery) store.StoreChannel {
+func (s sqlClusterDiscoveryStore) Save(ClusterDiscovery *model.ClusterDiscovery) *model.AppError {
-	return store.Do(func(result *store.StoreResult) {
+	ClusterDiscovery.PreSave()
-		ClusterDiscovery.PreSave()
+	if err := ClusterDiscovery.IsValid(); err != nil {
-		if result.Err = ClusterDiscovery.IsValid(); result.Err != nil {
+		return err
-			return
+	}
-		}
 
-		if err := s.GetMaster().Insert(ClusterDiscovery); err != nil {
+	if err := s.GetMaster().Insert(ClusterDiscovery); err != nil {
-			result.Err = model.NewAppError("SqlClusterDiscoveryStore.Save", "store.sql_cluster_discovery.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return model.NewAppError("SqlClusterDiscoveryStore.Save", "store.sql_cluster_discovery.save.app_error", nil, err.Error(), http.StatusInternalServerError)
-		}
+	}
-	})
+	return nil
 }
 
-func (s sqlClusterDiscoveryStore) Delete(ClusterDiscovery *model.ClusterDiscovery) store.StoreChannel {
+func (s sqlClusterDiscoveryStore) Delete(ClusterDiscovery *model.ClusterDiscovery) (bool, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	count, err := s.GetMaster().SelectInt(
-		result.Data = false
+		`
-
+		DELETE
-		if count, err := s.GetMaster().SelectInt(
+		FROM
-			`
+			ClusterDiscovery
-			DELETE
+		WHERE
-			FROM
+			Type = :Type
-				ClusterDiscovery
-			WHERE
-				Type = :Type
-					AND ClusterName = :ClusterName
-					AND Hostname = :Hostname
-			`,
-			map[string]interface{}{
-				"Type":        ClusterDiscovery.Type,
-				"ClusterName": ClusterDiscovery.ClusterName,
-				"Hostname":    ClusterDiscovery.Hostname,
-			},
-		); err != nil {
-			result.Err = model.NewAppError("SqlClusterDiscoveryStore.Delete", "store.sql_cluster_discovery.delete.app_error", nil, err.Error(), http.StatusInternalServerError)
-		} else {
-			if count > 0 {
-				result.Data = true
-			}
-		}
-	})
-}
-
-func (s sqlClusterDiscoveryStore) Exists(ClusterDiscovery *model.ClusterDiscovery) store.StoreChannel {
-	return store.Do(func(result *store.StoreResult) {
-		result.Data = false
-
-		if count, err := s.GetMaster().SelectInt(
-			`
-			SELECT
-				COUNT(*)
-			FROM
-				ClusterDiscovery
-			WHERE
-				Type = :Type
-					AND ClusterName = :ClusterName
-					AND Hostname = :Hostname
-			`,
-			map[string]interface{}{
-				"Type":        ClusterDiscovery.Type,
-				"ClusterName": ClusterDiscovery.ClusterName,
-				"Hostname":    ClusterDiscovery.Hostname,
-			},
-		); err != nil {
-			result.Err = model.NewAppError("SqlClusterDiscoveryStore.Exists", "store.sql_cluster_discovery.exists.app_error", nil, err.Error(), http.StatusInternalServerError)
-		} else {
-			if count > 0 {
-				result.Data = true
-			}
-		}
-	})
-}
-
-func (s sqlClusterDiscoveryStore) GetAll(ClusterDiscoveryType, clusterName string) store.StoreChannel {
-	return store.Do(func(result *store.StoreResult) {
-		lastPingAt := model.GetMillis() - model.CDS_OFFLINE_AFTER_MILLIS
-
-		var list []*model.ClusterDiscovery
-		if _, err := s.GetMaster().Select(
-			&list,
-			`
-			SELECT
-				*
-			FROM
-				ClusterDiscovery
-			WHERE
-				Type = :ClusterDiscoveryType
-					AND ClusterName = :ClusterName
-					AND LastPingAt > :LastPingAt
-			`,
-			map[string]interface{}{
-				"ClusterDiscoveryType": ClusterDiscoveryType,
-				"ClusterName":          clusterName,
-				"LastPingAt":           lastPingAt,
-			},
-		); err != nil {
-			result.Err = model.NewAppError("SqlClusterDiscoveryStore.GetAllForType", "store.sql_cluster_discovery.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
-		} else {
-			result.Data = list
-		}
-	})
-}
-
-func (s sqlClusterDiscoveryStore) SetLastPingAt(ClusterDiscovery *model.ClusterDiscovery) store.StoreChannel {
-	return store.Do(func(result *store.StoreResult) {
-		if _, err := s.GetMaster().Exec(
-			`
-			UPDATE ClusterDiscovery
-			SET
-				LastPingAt = :LastPingAt
-			WHERE
-				Type = :Type
 				AND ClusterName = :ClusterName
 				AND Hostname = :Hostname
-			`,
+		`,
-			map[string]interface{}{
+		map[string]interface{}{
-				"LastPingAt":  model.GetMillis(),
+			"Type":        ClusterDiscovery.Type,
-				"Type":        ClusterDiscovery.Type,
+			"ClusterName": ClusterDiscovery.ClusterName,
-				"ClusterName": ClusterDiscovery.ClusterName,
+			"Hostname":    ClusterDiscovery.Hostname,
-				"Hostname":    ClusterDiscovery.Hostname,
+		},
-			},
+	)
-		); err != nil {
+	if err != nil {
-			result.Err = model.NewAppError("SqlClusterDiscoveryStore.GetAllForType", "store.sql_cluster_discovery.set_last_ping.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return false, model.NewAppError("SqlClusterDiscoveryStore.Delete", "store.sql_cluster_discovery.delete.app_error", nil, err.Error(), http.StatusInternalServerError)
-		}
+	}
-	})
+	if count == 0 {
+		return false, nil
+	}
+	return true, nil
 }
 
-func (s sqlClusterDiscoveryStore) Cleanup() store.StoreChannel {
+func (s sqlClusterDiscoveryStore) Exists(ClusterDiscovery *model.ClusterDiscovery) (bool, *model.AppError) {
-	return store.Do(func(result *store.StoreResult) {
+	count, err := s.GetMaster().SelectInt(
-		if _, err := s.GetMaster().Exec(
+		`
-			`
+		SELECT
-			DELETE FROM ClusterDiscovery
+			COUNT(*)
-				WHERE
+		FROM
-					LastPingAt < :LastPingAt
+			ClusterDiscovery
-			`,
+		WHERE
-			map[string]interface{}{
+			Type = :Type
-				"LastPingAt": model.GetMillis() - model.CDS_OFFLINE_AFTER_MILLIS,
+				AND ClusterName = :ClusterName
-			},
+				AND Hostname = :Hostname
-		); err != nil {
+		`,
-			result.Err = model.NewAppError("SqlClusterDiscoveryStore.Save", "store.sql_cluster_discovery.cleanup.app_error", nil, err.Error(), http.StatusInternalServerError)
+		map[string]interface{}{
-		}
+			"Type":        ClusterDiscovery.Type,
-	})
+			"ClusterName": ClusterDiscovery.ClusterName,
+			"Hostname":    ClusterDiscovery.Hostname,
+		},
+	)
+	if err != nil {
+		return false, model.NewAppError("SqlClusterDiscoveryStore.Exists", "store.sql_cluster_discovery.exists.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	if count == 0 {
+		return false, nil
+	}
+	return true, nil
+}
+
+func (s sqlClusterDiscoveryStore) GetAll(ClusterDiscoveryType, clusterName string) ([]*model.ClusterDiscovery, *model.AppError) {
+	lastPingAt := model.GetMillis() - model.CDS_OFFLINE_AFTER_MILLIS
+
+	var list []*model.ClusterDiscovery
+	if _, err := s.GetMaster().Select(
+		&list,
+		`
+		SELECT
+			*
+		FROM
+			ClusterDiscovery
+		WHERE
+			Type = :ClusterDiscoveryType
+				AND ClusterName = :ClusterName
+				AND LastPingAt > :LastPingAt
+		`,
+		map[string]interface{}{
+			"ClusterDiscoveryType": ClusterDiscoveryType,
+			"ClusterName":          clusterName,
+			"LastPingAt":           lastPingAt,
+		},
+	); err != nil {
+		return nil, model.NewAppError("SqlClusterDiscoveryStore.GetAllForType", "store.sql_cluster_discovery.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	return list, nil
+}
+
+func (s sqlClusterDiscoveryStore) SetLastPingAt(ClusterDiscovery *model.ClusterDiscovery) *model.AppError {
+	if _, err := s.GetMaster().Exec(
+		`
+		UPDATE ClusterDiscovery
+		SET
+			LastPingAt = :LastPingAt
+		WHERE
+			Type = :Type
+			AND ClusterName = :ClusterName
+			AND Hostname = :Hostname
+		`,
+		map[string]interface{}{
+			"LastPingAt":  model.GetMillis(),
+			"Type":        ClusterDiscovery.Type,
+			"ClusterName": ClusterDiscovery.ClusterName,
+			"Hostname":    ClusterDiscovery.Hostname,
+		},
+	); err != nil {
+		return model.NewAppError("SqlClusterDiscoveryStore.GetAllForType", "store.sql_cluster_discovery.set_last_ping.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	return nil
+}
+
+func (s sqlClusterDiscoveryStore) Cleanup() *model.AppError {
+	if _, err := s.GetMaster().Exec(
+		`
+		DELETE FROM ClusterDiscovery
+			WHERE
+				LastPingAt < :LastPingAt
+		`,
+		map[string]interface{}{
+			"LastPingAt": model.GetMillis() - model.CDS_OFFLINE_AFTER_MILLIS,
+		},
+	); err != nil {
+		return model.NewAppError("SqlClusterDiscoveryStore.Save", "store.sql_cluster_discovery.cleanup.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	return nil
 }

store/store.go

@@ -329,12 +329,12 @@ type AuditStore interface {
 }
 
 type ClusterDiscoveryStore interface {
-	Save(discovery *model.ClusterDiscovery) StoreChannel
+	Save(discovery *model.ClusterDiscovery) *model.AppError
-	Delete(discovery *model.ClusterDiscovery) StoreChannel
+	Delete(discovery *model.ClusterDiscovery) (bool, *model.AppError)
-	Exists(discovery *model.ClusterDiscovery) StoreChannel
+	Exists(discovery *model.ClusterDiscovery) (bool, *model.AppError)
-	GetAll(discoveryType, clusterName string) StoreChannel
+	GetAll(discoveryType, clusterName string) ([]*model.ClusterDiscovery, *model.AppError)
-	SetLastPingAt(discovery *model.ClusterDiscovery) StoreChannel
+	SetLastPingAt(discovery *model.ClusterDiscovery) *model.AppError
-	Cleanup() StoreChannel
+	Cleanup() *model.AppError
 }
 
 type ComplianceStore interface {

store/storetest/cluster_discovery_store.go

@@ -10,6 +10,8 @@ import (
 
 	"github.com/mattermost/mattermost-server/model"
 	"github.com/mattermost/mattermost-server/store"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestClusterDiscoveryStore(t *testing.T, ss store.Store) {
@@ -27,12 +29,12 @@ func testClusterDiscoveryStore(t *testing.T, ss store.Store) {
 		Type:        "test_test",
 	}
 
-	if result := <-ss.ClusterDiscovery().Save(discovery); result.Err != nil {
+	if err := ss.ClusterDiscovery().Save(discovery); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 
-	if result := <-ss.ClusterDiscovery().Cleanup(); result.Err != nil {
+	if err := ss.ClusterDiscovery().Cleanup(); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 }
 
@@ -43,12 +45,12 @@ func testClusterDiscoveryStoreDelete(t *testing.T, ss store.Store) {
 		Type:        "test_test",
 	}
 
-	if result := <-ss.ClusterDiscovery().Save(discovery); result.Err != nil {
+	if err := ss.ClusterDiscovery().Save(discovery); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 
-	if result := <-ss.ClusterDiscovery().Delete(discovery); result.Err != nil {
+	if _, err := ss.ClusterDiscovery().Delete(discovery); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 }
 
@@ -59,35 +61,28 @@ func testClusterDiscoveryStoreLastPing(t *testing.T, ss store.Store) {
 		Type:        "test_test_lastPing" + model.NewId(),
 	}
 
-	if result := <-ss.ClusterDiscovery().Save(discovery); result.Err != nil {
+	if err := ss.ClusterDiscovery().Save(discovery); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 
-	if result := <-ss.ClusterDiscovery().SetLastPingAt(discovery); result.Err != nil {
+	if err := ss.ClusterDiscovery().SetLastPingAt(discovery); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 
 	ttime := model.GetMillis()
 
 	time.Sleep(1 * time.Second)
 
-	if result := <-ss.ClusterDiscovery().SetLastPingAt(discovery); result.Err != nil {
+	if err := ss.ClusterDiscovery().SetLastPingAt(discovery); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 
-	if result := <-ss.ClusterDiscovery().GetAll(discovery.Type, "cluster_name_lastPing"); result.Err != nil {
+	list, err := ss.ClusterDiscovery().GetAll(discovery.Type, "cluster_name_lastPing")
-		t.Fatal(result.Err)
+	require.Nil(t, err)
-	} else {
+	assert.Len(t, list, 1)
-		list := result.Data.([]*model.ClusterDiscovery)
 
-		if len(list) != 1 {
+	if list[0].LastPingAt-ttime < 500 {
-			t.Fatal("should only be 1 items")
+		t.Fatal("failed to set time")
-			return
-		}
-
-		if list[0].LastPingAt-ttime < 500 {
-			t.Fatal("failed to set time")
-		}
 	}
 
 	discovery2 := &model.ClusterDiscovery{
@@ -96,8 +91,8 @@ func testClusterDiscoveryStoreLastPing(t *testing.T, ss store.Store) {
 		Type:        "test_test_missing",
 	}
 
-	if result := <-ss.ClusterDiscovery().SetLastPingAt(discovery2); result.Err != nil {
+	if err := ss.ClusterDiscovery().SetLastPingAt(discovery2); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 }
 
@@ -108,29 +103,19 @@ func testClusterDiscoveryStoreExists(t *testing.T, ss store.Store) {
 		Type:        "test_test_Exists" + model.NewId(),
 	}
 
-	if result := <-ss.ClusterDiscovery().Save(discovery); result.Err != nil {
+	if err := ss.ClusterDiscovery().Save(discovery); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 
-	if result := <-ss.ClusterDiscovery().Exists(discovery); result.Err != nil {
+	val, err := ss.ClusterDiscovery().Exists(discovery)
-		t.Fatal(result.Err)
+	require.Nil(t, err)
-	} else {
+	assert.True(t, val)
-		val := result.Data.(bool)
-		if !val {
-			t.Fatal("should be true")
-		}
-	}
 
 	discovery.ClusterName = "cluster_name_Exists2"
 
-	if result := <-ss.ClusterDiscovery().Exists(discovery); result.Err != nil {
+	val, err = ss.ClusterDiscovery().Exists(discovery)
-		t.Fatal(result.Err)
+	require.Nil(t, err)
-	} else {
+	assert.False(t, val)
-		val := result.Data.(bool)
-		if val {
-			t.Fatal("should be true")
-		}
-	}
 }
 
 func testClusterDiscoveryGetStore(t *testing.T, ss store.Store) {
@@ -141,14 +126,14 @@ func testClusterDiscoveryGetStore(t *testing.T, ss store.Store) {
 		Hostname:    "hostname1",
 		Type:        testType1,
 	}
-	store.Must(ss.ClusterDiscovery().Save(discovery1))
+	require.Nil(t, ss.ClusterDiscovery().Save(discovery1))
 
 	discovery2 := &model.ClusterDiscovery{
 		ClusterName: "cluster_name",
 		Hostname:    "hostname2",
 		Type:        testType1,
 	}
-	store.Must(ss.ClusterDiscovery().Save(discovery2))
+	require.Nil(t, ss.ClusterDiscovery().Save(discovery2))
 
 	discovery3 := &model.ClusterDiscovery{
 		ClusterName: "cluster_name",
@@ -157,7 +142,7 @@ func testClusterDiscoveryGetStore(t *testing.T, ss store.Store) {
 		CreateAt:    1,
 		LastPingAt:  1,
 	}
-	store.Must(ss.ClusterDiscovery().Save(discovery3))
+	require.Nil(t, ss.ClusterDiscovery().Save(discovery3))
 
 	testType2 := model.NewId()
 
@@ -166,35 +151,17 @@ func testClusterDiscoveryGetStore(t *testing.T, ss store.Store) {
 		Hostname:    "hostname1",
 		Type:        testType2,
 	}
-	store.Must(ss.ClusterDiscovery().Save(discovery4))
+	require.Nil(t, ss.ClusterDiscovery().Save(discovery4))
 
-	if result := <-ss.ClusterDiscovery().GetAll(testType1, "cluster_name"); result.Err != nil {
+	list, err := ss.ClusterDiscovery().GetAll(testType1, "cluster_name")
-		t.Fatal(result.Err)
+	require.Nil(t, err)
-	} else {
+	assert.Len(t, list, 2)
-		list := result.Data.([]*model.ClusterDiscovery)
 
-		if len(list) != 2 {
+	list, err = ss.ClusterDiscovery().GetAll(testType2, "cluster_name")
-			t.Fatal("Should only have returned 2")
+	require.Nil(t, err)
-		}
+	assert.Len(t, list, 1)
-	}
 
-	if result := <-ss.ClusterDiscovery().GetAll(testType2, "cluster_name"); result.Err != nil {
+	list, err = ss.ClusterDiscovery().GetAll(model.NewId(), "cluster_name")
-		t.Fatal(result.Err)
+	require.Nil(t, err)
-	} else {
+	assert.Len(t, list, 0)
-		list := result.Data.([]*model.ClusterDiscovery)
-
-		if len(list) != 1 {
-			t.Fatal("Should only have returned 1")
-		}
-	}
-
-	if result := <-ss.ClusterDiscovery().GetAll(model.NewId(), "cluster_name"); result.Err != nil {
-		t.Fatal(result.Err)
-	} else {
-		list := result.Data.([]*model.ClusterDiscovery)
-
-		if len(list) != 0 {
-			t.Fatal("shouldn't be any")
-		}
-	}
 }

store/storetest/mocks/ClusterDiscoveryStore.go

@@ -6,7 +6,6 @@ package mocks
 
 import mock "github.com/stretchr/testify/mock"
 import model "github.com/mattermost/mattermost-server/model"
-import store "github.com/mattermost/mattermost-server/store"
 
 // ClusterDiscoveryStore is an autogenerated mock type for the ClusterDiscoveryStore type
 type ClusterDiscoveryStore struct {
@@ -14,15 +13,15 @@ type ClusterDiscoveryStore struct {
 }
 
 // Cleanup provides a mock function with given fields:
-func (_m *ClusterDiscoveryStore) Cleanup() store.StoreChannel {
+func (_m *ClusterDiscoveryStore) Cleanup() *model.AppError {
 	ret := _m.Called()
 
-	var r0 store.StoreChannel
+	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func() store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func() *model.AppError); ok {
 		r0 = rf()
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.AppError)
 		}
 	}
 
@@ -30,63 +29,86 @@ func (_m *ClusterDiscoveryStore) Cleanup() store.StoreChannel {
 }
 
 // Delete provides a mock function with given fields: discovery
-func (_m *ClusterDiscoveryStore) Delete(discovery *model.ClusterDiscovery) store.StoreChannel {
+func (_m *ClusterDiscoveryStore) Delete(discovery *model.ClusterDiscovery) (bool, *model.AppError) {
 	ret := _m.Called(discovery)
 
-	var r0 store.StoreChannel
+	var r0 bool
-	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) bool); ok {
 		r0 = rf(discovery)
 	} else {
-		if ret.Get(0) != nil {
+		r0 = ret.Get(0).(bool)
-			r0 = ret.Get(0).(store.StoreChannel)
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.ClusterDiscovery) *model.AppError); ok {
+		r1 = rf(discovery)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
 		}
 	}
 
-	return r0
+	return r0, r1
 }
 
 // Exists provides a mock function with given fields: discovery
-func (_m *ClusterDiscoveryStore) Exists(discovery *model.ClusterDiscovery) store.StoreChannel {
+func (_m *ClusterDiscoveryStore) Exists(discovery *model.ClusterDiscovery) (bool, *model.AppError) {
 	ret := _m.Called(discovery)
 
-	var r0 store.StoreChannel
+	var r0 bool
-	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) bool); ok {
 		r0 = rf(discovery)
 	} else {
-		if ret.Get(0) != nil {
+		r0 = ret.Get(0).(bool)
-			r0 = ret.Get(0).(store.StoreChannel)
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.ClusterDiscovery) *model.AppError); ok {
+		r1 = rf(discovery)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
 		}
 	}
 
-	return r0
+	return r0, r1
 }
 
 // GetAll provides a mock function with given fields: discoveryType, clusterName
-func (_m *ClusterDiscoveryStore) GetAll(discoveryType string, clusterName string) store.StoreChannel {
+func (_m *ClusterDiscoveryStore) GetAll(discoveryType string, clusterName string) ([]*model.ClusterDiscovery, *model.AppError) {
 	ret := _m.Called(discoveryType, clusterName)
 
-	var r0 store.StoreChannel
+	var r0 []*model.ClusterDiscovery
-	if rf, ok := ret.Get(0).(func(string, string) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(string, string) []*model.ClusterDiscovery); ok {
 		r0 = rf(discoveryType, clusterName)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).([]*model.ClusterDiscovery)
 		}
 	}
 
-	return r0
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
+		r1 = rf(discoveryType, clusterName)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
 // Save provides a mock function with given fields: discovery
-func (_m *ClusterDiscoveryStore) Save(discovery *model.ClusterDiscovery) store.StoreChannel {
+func (_m *ClusterDiscoveryStore) Save(discovery *model.ClusterDiscovery) *model.AppError {
 	ret := _m.Called(discovery)
 
-	var r0 store.StoreChannel
+	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) *model.AppError); ok {
 		r0 = rf(discovery)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.AppError)
 		}
 	}
 
@@ -94,15 +116,15 @@ func (_m *ClusterDiscoveryStore) Save(discovery *model.ClusterDiscovery) store.S
 }
 
 // SetLastPingAt provides a mock function with given fields: discovery
-func (_m *ClusterDiscoveryStore) SetLastPingAt(discovery *model.ClusterDiscovery) store.StoreChannel {
+func (_m *ClusterDiscoveryStore) SetLastPingAt(discovery *model.ClusterDiscovery) *model.AppError {
 	ret := _m.Called(discovery)
 
-	var r0 store.StoreChannel
+	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(*model.ClusterDiscovery) *model.AppError); ok {
 		r0 = rf(discovery)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.AppError)
 		}
 	}