scheduler: add disable to independent config

pkg/mcs/scheduling/server/config/watcher.go

@@ -60,6 +60,7 @@ type Watcher struct {
 	*PersistConfig
 	// Some data, like the scheduler configs, should be loaded into the storage
 	// to make sure the coordinator could access them correctly.
+	// It is a memory storage.
 	storage storage.Storage
 	// schedulersController is used to trigger the scheduler's config reloading.
 	// Store as `*schedulers.Controller`.

pkg/schedule/schedulers/balance_leader.go

@@ -33,7 +33,6 @@
 	"github.com/tikv/pd/pkg/schedule/plan"
 	"github.com/tikv/pd/pkg/schedule/types"
 	"github.com/tikv/pd/pkg/utils/reflectutil"
-	"github.com/tikv/pd/pkg/utils/syncutil"
 	"github.com/tikv/pd/pkg/utils/typeutil"
 	"github.com/unrolled/render"
 	"go.uber.org/zap"
@@ -52,8 +51,7 @@
 )
 
 type balanceLeaderSchedulerConfig struct {
-	syncutil.RWMutex
-	schedulerConfig
+	baseDefaultSchedulerConfig
 
 	Ranges []core.KeyRange `json:"ranges"`
 	// Batch is used to generate multiple operators by one scheduling
@@ -164,7 +162,7 @@
 // each store balanced.
 func newBalanceLeaderScheduler(opController *operator.Controller, conf *balanceLeaderSchedulerConfig, options ...BalanceLeaderCreateOption) Scheduler {
 	s := &balanceLeaderScheduler{
-		BaseScheduler: NewBaseScheduler(opController, types.BalanceLeaderScheduler),
+		BaseScheduler: NewBaseScheduler(opController, types.BalanceLeaderScheduler, conf),
 		retryQuota:    newRetryQuota(),
 		conf:          conf,
 		handler:       newBalanceLeaderHandler(conf),
@@ -541,3 +539,18 @@
 	op.SetAdditionalInfo("targetScore", strconv.FormatFloat(solver.targetScore, 'f', 2, 64))
 	return op
 }
+
+// IsDiable implements the Scheduler interface.
+func (l *balanceLeaderScheduler) IsDisable() bool {
+	return l.conf.isDisable()
+}
+
+// SetDiable implements the Scheduler interface.
+func (l *balanceLeaderScheduler) SetDisable(disable bool) error {
+	return l.conf.setDisable(disable)
+}
+
+// IsDefault implements the Scheduler interface.
+func (*balanceLeaderScheduler) IsDefault() bool {
+	return true
+}

pkg/schedule/schedulers/balance_region.go

@@ -31,6 +31,8 @@
 )
 
 type balanceRegionSchedulerConfig struct {
+	baseDefaultSchedulerConfig
+
 	Ranges []core.KeyRange `json:"ranges"`
 	// TODO: When we prepare to use Ranges, we will need to implement the ReloadConfig function for this scheduler.
 }
@@ -48,7 +50,7 @@
 // each store balanced.
 func newBalanceRegionScheduler(opController *operator.Controller, conf *balanceRegionSchedulerConfig, opts ...BalanceRegionCreateOption) Scheduler {
 	scheduler := &balanceRegionScheduler{
-		BaseScheduler: NewBaseScheduler(opController, types.BalanceRegionScheduler),
+		BaseScheduler: NewBaseScheduler(opController, types.BalanceRegionScheduler, conf),
 		retryQuota:    newRetryQuota(),
 		name:          types.BalanceRegionScheduler.String(),
 		conf:          conf,
@@ -266,3 +268,18 @@
 	}
 	return nil
 }
+
+// IsDiable implements the Scheduler interface.
+func (s *balanceRegionScheduler) IsDisable() bool {
+	return s.conf.isDisable()
+}
+
+// SetDiable implements the Scheduler interface.
+func (s *balanceRegionScheduler) SetDisable(disable bool) error {
+	return s.conf.setDisable(disable)
+}
+
+// IsDefault implements the Scheduler interface.
+func (*balanceRegionScheduler) IsDefault() bool {
+	return true
+}

pkg/schedule/schedulers/balance_witness.go

@@ -162,7 +162,7 @@ type balanceWitnessScheduler struct {
 // each store balanced.
 func newBalanceWitnessScheduler(opController *operator.Controller, conf *balanceWitnessSchedulerConfig, options ...BalanceWitnessCreateOption) Scheduler {
 	s := &balanceWitnessScheduler{
-		BaseScheduler: NewBaseScheduler(opController, types.BalanceWitnessScheduler),
+		BaseScheduler: NewBaseScheduler(opController, types.BalanceWitnessScheduler, conf),
 		retryQuota:    newRetryQuota(),
 		conf:          conf,
 		handler:       newBalanceWitnessHandler(conf),

pkg/schedule/schedulers/base_scheduler.go

@@ -65,11 +65,16 @@
 
 	name string
 	tp   types.CheckerSchedulerType
+	conf schedulerConfig
 }
 
 // NewBaseScheduler returns a basic scheduler
-func NewBaseScheduler(opController *operator.Controller, tp types.CheckerSchedulerType) *BaseScheduler {
-	return &BaseScheduler{OpController: opController, tp: tp}
+func NewBaseScheduler(
+	opController *operator.Controller,
+	tp types.CheckerSchedulerType,
+	conf schedulerConfig,
+) *BaseScheduler {
+	return &BaseScheduler{OpController: opController, tp: tp, conf: conf}
 }
 
 func (*BaseScheduler) ServeHTTP(w http.ResponseWriter, _ *http.Request) {
@@ -114,3 +119,12 @@
 func (s *BaseScheduler) GetType() types.CheckerSchedulerType {
 	return s.tp
 }
+
+// IsDiable implements the Scheduler interface.
+func (*BaseScheduler) IsDisable() bool { return false }
+
+// SetDisable implements the Scheduler interface.
+func (*BaseScheduler) SetDisable(bool) error { return nil }
+
+// IsDefault returns if the scheduler is a default scheduler.
+func (*BaseScheduler) IsDefault() bool { return false }

pkg/schedule/schedulers/config.go

@@ -17,15 +17,21 @@ package schedulers
 import (
 	"github.com/pingcap/errors"
 	"github.com/pingcap/failpoint"
+	"github.com/pingcap/log"
+	"github.com/tikv/pd/pkg/errs"
 	"github.com/tikv/pd/pkg/storage/endpoint"
+	"github.com/tikv/pd/pkg/utils/syncutil"
+	"go.uber.org/zap"
 )
 
 type schedulerConfig interface {
+	init(name string, storage endpoint.ConfigStorage, data any)
 	save() error
 	load(any) error
-	init(name string, storage endpoint.ConfigStorage, data any)
 }
 
+var _ schedulerConfig = &baseSchedulerConfig{}
+
 type baseSchedulerConfig struct {
 	name    string
 	storage endpoint.ConfigStorage
@@ -58,3 +64,33 @@ func (b *baseSchedulerConfig) load(v any) error {
 	}
 	return DecodeConfig([]byte(data), v)
 }
+
+type baseDefaultSchedulerConfig struct {
+	schedulerConfig
+	syncutil.RWMutex
+
+	Disabled bool `json:"disabled"`
+}
+
+func newBaseDefaultSchedulerConfig() baseDefaultSchedulerConfig {
+	return baseDefaultSchedulerConfig{
+		schedulerConfig: &baseSchedulerConfig{},
+	}
+}
+
+func (b *baseDefaultSchedulerConfig) isDisable() bool {
+	b.Lock()
+	defer b.Unlock()
+	if err := b.load(b); err != nil {
+		log.Warn("failed to load scheduler config, maybe the config never persist", errs.ZapError(err))
+	}
+	return b.Disabled
+}
+
+func (b *baseDefaultSchedulerConfig) setDisable(disabled bool) error {
+	b.Lock()
+	defer b.Unlock()
+	b.Disabled = disabled
+	log.Info("set scheduler disable", zap.Bool("disabled", disabled))
+	return b.save()
+}

pkg/schedule/schedulers/config_test.go

@@ -48,3 +48,36 @@ func TestSchedulerConfig(t *testing.T) {
 	// report error because the config is empty and cannot be decoded
 	require.Error(t, cfg2.load(newTc))
 }
+
+func TestDefaultSchedulerConfig(t *testing.T) {
+	s := storage.NewStorageWithMemoryBackend()
+
+	type testConfig struct {
+		balanceLeaderSchedulerConfig
+		Value string `json:"value"`
+	}
+
+	cfg := &testConfig{
+		balanceLeaderSchedulerConfig: balanceLeaderSchedulerConfig{
+			baseDefaultSchedulerConfig: newBaseDefaultSchedulerConfig(),
+		},
+		Value: "test",
+	}
+	cfg.init("test", s, cfg)
+	require.False(t, cfg.isDisable())
+	require.NoError(t, cfg.setDisable(true))
+	require.True(t, cfg.isDisable())
+
+	cfg2 := &testConfig{
+		balanceLeaderSchedulerConfig: balanceLeaderSchedulerConfig{
+			baseDefaultSchedulerConfig: newBaseDefaultSchedulerConfig(),
+		},
+	}
+	cfg2.init("test", s, cfg2)
+	require.True(t, cfg2.isDisable())
+	require.Equal(t, "", cfg2.Value)
+
+	cfg3 := &testConfig{}
+	require.NoError(t, cfg2.load(cfg3))
+	require.Equal(t, cfg.Value, cfg3.Value)
+}

pkg/schedule/schedulers/evict_leader.go

@@ -231,7 +231,7 @@ type evictLeaderScheduler struct {
 func newEvictLeaderScheduler(opController *operator.Controller, conf *evictLeaderSchedulerConfig) Scheduler {
 	handler := newEvictLeaderHandler(conf)
 	return &evictLeaderScheduler{
-		BaseScheduler: NewBaseScheduler(opController, types.EvictLeaderScheduler),
+		BaseScheduler: NewBaseScheduler(opController, types.EvictLeaderScheduler, conf),
 		conf:          conf,
 		handler:       handler,
 	}

pkg/schedule/schedulers/evict_slow_store.go

@@ -28,7 +28,6 @@
 	"github.com/tikv/pd/pkg/schedule/plan"
 	"github.com/tikv/pd/pkg/schedule/types"
 	"github.com/tikv/pd/pkg/utils/apiutil"
-	"github.com/tikv/pd/pkg/utils/syncutil"
 	"github.com/unrolled/render"
 	"go.uber.org/zap"
 )
@@ -39,8 +38,7 @@
 )
 
 type evictSlowStoreSchedulerConfig struct {
-	syncutil.RWMutex
-	schedulerConfig
+	baseDefaultSchedulerConfig
 
 	cluster *core.BasicCluster
 	// Last timestamp of the chosen slow store for eviction.
@@ -52,10 +50,10 @@
 
 func initEvictSlowStoreSchedulerConfig() *evictSlowStoreSchedulerConfig {
 	return &evictSlowStoreSchedulerConfig{
-		schedulerConfig:        &baseSchedulerConfig{},
-		lastSlowStoreCaptureTS: time.Time{},
-		RecoveryDurationGap:    defaultRecoveryDurationGap,
-		EvictedStores:          make([]uint64, 0),
+		baseDefaultSchedulerConfig: newBaseDefaultSchedulerConfig(),
+		lastSlowStoreCaptureTS:     time.Time{},
+		RecoveryDurationGap:        defaultRecoveryDurationGap,
+		EvictedStores:              make([]uint64, 0),
 	}
 }
 
@@ -310,12 +308,27 @@
 	return s.schedulerEvictLeader(cluster), nil
 }
 
+// IsDiable implements the Scheduler interface.
+func (s *evictSlowStoreScheduler) IsDisable() bool {
+	return s.conf.isDisable()
+}
+
+// SetDisable implements the Scheduler interface.
+func (s *evictSlowStoreScheduler) SetDisable(disable bool) error {
+	return s.conf.setDisable(disable)
+}
+
 // newEvictSlowStoreScheduler creates a scheduler that detects and evicts slow stores.
 func newEvictSlowStoreScheduler(opController *operator.Controller, conf *evictSlowStoreSchedulerConfig) Scheduler {
 	handler := newEvictSlowStoreHandler(conf)
 	return &evictSlowStoreScheduler{
-		BaseScheduler: NewBaseScheduler(opController, types.EvictSlowStoreScheduler),
+		BaseScheduler: NewBaseScheduler(opController, types.EvictSlowStoreScheduler, conf),
 		conf:          conf,
 		handler:       handler,
 	}
 }
+
+// IsDefault implements the Scheduler interface.
+func (*evictSlowStoreScheduler) IsDefault() bool {
+	return true
+}

pkg/schedule/schedulers/evict_slow_trend.go

@@ -435,7 +435,7 @@ func (s *evictSlowTrendScheduler) Schedule(cluster sche.SchedulerCluster, _ bool
 func newEvictSlowTrendScheduler(opController *operator.Controller, conf *evictSlowTrendSchedulerConfig) Scheduler {
 	handler := newEvictSlowTrendHandler(conf)
 	sche := &evictSlowTrendScheduler{
-		BaseScheduler: NewBaseScheduler(opController, types.EvictSlowTrendScheduler),
+		BaseScheduler: NewBaseScheduler(opController, types.EvictSlowTrendScheduler, conf),
 		conf:          conf,
 		handler:       handler,
 	}

pkg/schedule/schedulers/grant_hot_region.go

@@ -116,8 +116,8 @@ type grantHotRegionScheduler struct {
 
 // newGrantHotRegionScheduler creates an admin scheduler that transfers hot region peer to fixed store and hot region leader to one store.
 func newGrantHotRegionScheduler(opController *operator.Controller, conf *grantHotRegionSchedulerConfig) *grantHotRegionScheduler {
-	base := newBaseHotScheduler(opController,
-		statistics.DefaultHistorySampleDuration, statistics.DefaultHistorySampleInterval)
+	base := newBaseHotScheduler(opController, statistics.DefaultHistorySampleDuration,
+		statistics.DefaultHistorySampleInterval, conf)
 	base.tp = types.GrantHotRegionScheduler
 	handler := newGrantHotRegionHandler(conf)
 	ret := &grantHotRegionScheduler{

pkg/schedule/schedulers/grant_leader.go

@@ -144,7 +144,7 @@ type grantLeaderScheduler struct {
 // newGrantLeaderScheduler creates an admin scheduler that transfers all leaders
 // to a store.
 func newGrantLeaderScheduler(opController *operator.Controller, conf *grantLeaderSchedulerConfig) Scheduler {
-	base := NewBaseScheduler(opController, types.GrantLeaderScheduler)
+	base := NewBaseScheduler(opController, types.GrantLeaderScheduler, conf)
 	handler := newGrantLeaderHandler(conf)
 	return &grantLeaderScheduler{
 		BaseScheduler: base,

pkg/schedule/schedulers/hot_region.go

@@ -88,8 +88,12 @@
 	updateWriteTime time.Time
 }
 
-func newBaseHotScheduler(opController *operator.Controller, sampleDuration time.Duration, sampleInterval time.Duration) *baseHotScheduler {
-	base := NewBaseScheduler(opController, types.BalanceHotRegionScheduler)
+func newBaseHotScheduler(
+	opController *operator.Controller,
+	sampleDuration, sampleInterval time.Duration,
+	schedulerConfig schedulerConfig,
+) *baseHotScheduler {
+	base := NewBaseScheduler(opController, types.BalanceHotRegionScheduler, schedulerConfig)
 	ret := &baseHotScheduler{
 		BaseScheduler:  base,
 		regionPendings: make(map[uint64]*pendingInfluence),
@@ -197,8 +201,8 @@
 }
 
 func newHotScheduler(opController *operator.Controller, conf *hotRegionSchedulerConfig) *hotScheduler {
-	base := newBaseHotScheduler(opController,
-		conf.getHistorySampleDuration(), conf.getHistorySampleInterval())
+	base := newBaseHotScheduler(opController, conf.getHistorySampleDuration(),
+		conf.getHistorySampleInterval(), conf)
 	ret := &hotScheduler{
 		baseHotScheduler: base,
 		conf:             conf,
@@ -280,6 +284,16 @@
 	return h.dispatch(typ, cluster), nil
 }
 
+// IsDisable implements the Scheduler interface.
+func (h *hotScheduler) IsDisable() bool {
+	return h.conf.isDisable()
+}
+
+// SetDisable implements the Scheduler interface.
+func (h *hotScheduler) SetDisable(disable bool) error {
+	return h.conf.setDisable(disable)
+}
+
 func (h *hotScheduler) dispatch(typ resourceType, cluster sche.SchedulerCluster) []*operator.Operator {
 	h.Lock()
 	defer h.Unlock()
@@ -386,6 +400,11 @@
 	return nil
 }
 
+// IsDefault implements the Scheduler interface.
+func (*hotScheduler) IsDefault() bool {
+	return true
+}
+
 type solution struct {
 	srcStore     *statistics.StoreLoadDetail
 	region       *core.RegionInfo // The region of the main balance effect. Relate mainPeerStat. srcStore -> dstStore