config

type Config struct {
	Name             string            `toml:"name" json:"name"`
	DataDir          string            `toml:"data-dir"`
	RPCAddr          string            `toml:"rpc-addr"`
	AdvertiseRPCAddr string            `toml:"rpc-advertise-addr"`
	RPCTimeout       typeutil.Duration `toml:"rpc-timeout"`

	// etcd configuration
	StorageNode  bool            `toml:"storage-node"`
	ExternalEtcd []string        `toml:"external-etcd"`
	EmbedEtcd    EmbedEtcdConfig `toml:"embed-etcd"`

	// LeaderLease time, if leader doesn't update its TTL
	// in etcd after lease time, etcd will expire the leader key
	// and other servers can campaign the leader again.
	// Etcd only supports seconds TTL, so here is second too.
	LeaderLease int64 `toml:"lease" json:"lease"`

	Schedule      ScheduleConfig      `toml:"schedule" json:"schedule"`
	Replication   ReplicationConfig   `toml:"replication" json:"replication"`
	LabelProperty LabelPropertyConfig `toml:"label-property" json:"label-property"`

	Handler                         metadata.RoleChangeHandler                                                      `toml:"-" json:"-"`
	Adapter                         metadata.Adapter                                                                `toml:"-" json:"-"`
	ResourceStateChangedHandler     func(res metadata.Resource, from metapb.ResourceState, to metapb.ResourceState) `toml:"-" json:"-"`
	ContainerHeartbeatDataProcessor ContainerHeartbeatDataProcessor                                                 `toml:"-" json:"-"`

	// TODO(fagongzi): the following test-related configurations are moved to a separate struct
	// Only test can change them.
	DisableStrictReconfigCheck bool `toml:"-" json:"-"`
	// DisableResponse skip all client request
	DisableResponse bool `toml:"-" json:"-"`
	// EnableResponseNotLeader return not leader error for all client request
	EnableResponseNotLeader bool      `toml:"-" json:"-"`
	TestCtx                 *sync.Map `toml:"-" json:"-"`
	// contains filtered or unexported fields
}

type ContainerHeartbeatDataProcessor interface {
	// Start init all customize data if the current node became the prophet leader
	Start(storage.Storage) error
	// Stop clear all customize data at current node, and other node became leader and will call `Start`
	Stop(storage.Storage) error
	// HandleHeartbeatReq handle the data from store heartbeat at the prophet leader node
	HandleHeartbeatReq(id uint64, data []byte, store storage.Storage) (responseData []byte, err error)
}

type ContainerLabel struct {
	Key   string `toml:"key" json:"key"`
	Value string `toml:"value" json:"value"`
}

type ContainerLimit struct {

	// AddPeer is the default rate of adding peers for container limit (per minute).
	AddPeer float64
	// RemovePeer is the default rate of removing peers for container limit (per minute).
	RemovePeer float64
	// contains filtered or unexported fields
}

type ContainerLimitConfig struct {
	AddPeer    float64 `toml:"add-peer" json:"add-peer"`
	RemovePeer float64 `toml:"remove-peer" json:"remove-peer"`
}

type EmbedEtcdConfig struct {
	Join                string `toml:"join"`
	ClientUrls          string `toml:"client-urls"`
	PeerUrls            string `toml:"peer-urls"`
	AdvertiseClientUrls string `toml:"advertise-client-urls"`
	AdvertisePeerUrls   string `toml:"advertise-peer-urls"`
	InitialCluster      string `toml:"initial-cluster"`
	InitialClusterState string `toml:"initial-cluster-state"`
	// TickInterval is the interval for etcd Raft tick.
	TickInterval typeutil.Duration `toml:"tick-interval"`
	// ElectionInterval is the interval for etcd Raft election.
	ElectionInterval typeutil.Duration `toml:"election-interval"`
	// Prevote is true to enable Raft Pre-Vote.
	// If enabled, Raft runs an additional election phase
	// to check whether it would get enough votes to win
	// an election, thus minimizing disruptions.
	PreVote bool `toml:"enable-prevote"`
	// AutoCompactionMode is either 'periodic' or 'revision'. The default value is 'periodic'.
	AutoCompactionMode string `toml:"auto-compaction-mode"`
	// AutoCompactionRetention is either duration string with time unit
	// (e.g. '5m' for 5-minute), or revision unit (e.g. '5000').
	// If no time unit is provided and compaction mode is 'periodic',
	// the unit defaults to hour. For example, '5' translates into 5-hour.
	// The default retention is 1 hour.
	// Before etcd v3.3.x, the type of retention is int. We add 'v2' suffix to make it backward compatible.
	AutoCompactionRetention string `toml:"auto-compaction-retention"`
	// QuotaBackendBytes Raise alarms when backend size exceeds the given quota. 0 means use the default quota.
	// the default size is 2GB, the maximum is 8GB.
	QuotaBackendBytes typeutil.ByteSize `toml:"quota-backend-bytes" json:"quota-backend-bytes"`
}

type JobProcessor interface {
	// Start create the job
	Start(metapb.Job, storage.JobStorage, ResourcesAware)
	// Stop stop the job, the job will restart at other node
	Stop(metapb.Job, storage.JobStorage, ResourcesAware)
	// Remove remove job, the job will never start again
	Remove(metapb.Job, storage.JobStorage, ResourcesAware)
	// Execute execute the data on job and returns the result
	Execute([]byte, storage.JobStorage, ResourcesAware) ([]byte, error)
}

type LabelPropertyConfig map[string][]ContainerLabel

type PersistOptions struct {
	// contains filtered or unexported fields
}

type ReplicationConfig struct {
	// MaxReplicas is the number of replicas for each resource.
	MaxReplicas uint64 `toml:"max-replicas" json:"max-replicas"`

	// The label keys specified the location of a container.
	// The placement priorities is implied by the order of label keys.
	// For example, ["zone", "rack"] means that we should place replicas to
	// different zones first, then to different racks if we don't have enough zones.
	LocationLabels typeutil.StringSlice `toml:"location-labels" json:"location-labels"`
	// StrictlyMatchLabel strictly checks if the label of your storage application is matched with LocationLabels.
	StrictlyMatchLabel bool `toml:"strictly-match-label" json:"strictly-match-label,string"`

	// When PlacementRules feature is enabled. MaxReplicas, LocationLabels and IsolationLabels are not used any more.
	EnablePlacementRules bool `toml:"enable-placement-rules" json:"enable-placement-rules,string"`

	// IsolationLevel is used to isolate replicas explicitly and forcibly if it's not empty.
	// Its value must be empty or one of LocationLabels.
	// Example:
	// location-labels = ["zone", "rack", "host"]
	// isolation-level = "zone"
	// With configuration like above, Prophet ensure that all replicas be placed in different zones.
	// Even if a zone is down, Prophet will not try to make up replicas in other zone
	// because other zones already have replicas on it.
	IsolationLevel string `toml:"isolation-level" json:"isolation-level"`

	// Groups resources groups
	Groups []uint64 `toml:"groups" json:"groups"`
}

type ResourcesAware interface {
	// ForeachWaittingCreateResources do every waitting resources
	ForeachWaittingCreateResources(do func(res metadata.Resource))
	// ForeachResources foreach resource by group
	ForeachResources(group uint64, fn func(res metadata.Resource))
	// GetResource returns resource runtime info
	GetResource(resourceID uint64) *core.CachedResource
}

type ScheduleConfig struct {
	// If the snapshot count of one container is greater than this value,
	// it will never be used as a source or target container.
	MaxSnapshotCount    uint64 `toml:"max-snapshot-count" json:"max-snapshot-count"`
	MaxPendingPeerCount uint64 `toml:"max-pending-peer-count" json:"max-pending-peer-count"`
	// If both the size of resource is smaller than MaxMergeResourceSize
	// and the number of rows in resource is smaller than MaxMergeResourceKeys,
	// it will try to merge with adjacent resources.
	MaxMergeResourceSize uint64 `toml:"max-merge-resource-size" json:"max-merge-resource-size"`
	MaxMergeResourceKeys uint64 `toml:"max-merge-resource-keys" json:"max-merge-resource-keys"`
	// SplitMergeInterval is the minimum interval time to permit merge after split.
	SplitMergeInterval typeutil.Duration `toml:"split-merge-interval" json:"split-merge-interval"`
	// EnableOneWayMerge is the option to enable one way merge. This means a resource can only be merged into the next resource of it.
	EnableOneWayMerge bool `toml:"enable-one-way-merge" json:"enable-one-way-merge,string"`
	// EnableCrossTableMerge is the option to enable cross table merge. This means two resources can be merged with different table IDs.
	// This option only works when key type is "table".
	EnableCrossTableMerge bool `toml:"enable-cross-table-merge" json:"enable-cross-table-merge,string"`
	// PatrolResourceInterval is the interval for scanning resource during patrol.
	PatrolResourceInterval typeutil.Duration `toml:"patrol-resource-interval" json:"patrol-resource-interval"`
	// MaxContainerDownTime is the max duration after which
	// a container will be considered to be down if it hasn't reported heartbeats.
	MaxContainerDownTime typeutil.Duration `toml:"max-container-down-time" json:"max-container-down-time"`
	// LeaderScheduleLimit is the max coexist leader schedules.
	LeaderScheduleLimit uint64 `toml:"leader-schedule-limit" json:"leader-schedule-limit"`
	// LeaderSchedulePolicy is the option to balance leader, there are some policies supported: ["count", "size"], default: "count"
	LeaderSchedulePolicy string `toml:"leader-schedule-policy" json:"leader-schedule-policy"`
	// ResourceScheduleLimit is the max coexist resource schedules.
	ResourceScheduleLimit uint64 `toml:"resource-schedule-limit" json:"resource-schedule-limit"`
	// ReplicaScheduleLimit is the max coexist replica schedules.
	ReplicaScheduleLimit uint64 `toml:"replica-schedule-limit" json:"replica-schedule-limit"`
	// MergeScheduleLimit is the max coexist merge schedules.
	MergeScheduleLimit uint64 `toml:"merge-schedule-limit" json:"merge-schedule-limit"`
	// HotResourceScheduleLimit is the max coexist hot resource schedules.
	HotResourceScheduleLimit uint64 `toml:"hot-resource-schedule-limit" json:"hot-resource-schedule-limit"`
	// HotResourceCacheHitsThreshold is the cache hits threshold of the hot resource.
	// If the number of times a resource hits the hot cache is greater than this
	// threshold, it is considered a hot resource.
	HotResourceCacheHitsThreshold uint64 `toml:"hot-resource-cache-hits-threshold" json:"hot-resource-cache-hits-threshold"`
	// ContainerLimit is the limit of scheduling for containers.
	ContainerLimit map[uint64]ContainerLimitConfig `toml:"container-limit" json:"container-limit"`
	// TolerantSizeRatio is the ratio of buffer size for balance scheduler.
	TolerantSizeRatio float64 `toml:"tolerant-size-ratio" json:"tolerant-size-ratio"`
	//
	//      high space stage         transition stage           low space stage
	//   |--------------------|-----------------------------|-------------------------|
	//   ^                    ^                             ^                         ^
	//   0       HighSpaceRatio * capacity       LowSpaceRatio * capacity          capacity
	//
	// LowSpaceRatio is the lowest usage ratio of container which regraded as low space.
	// When in low space, container resource score increases to very large and varies inversely with available size.
	LowSpaceRatio float64 `toml:"low-space-ratio" json:"low-space-ratio"`
	// HighSpaceRatio is the highest usage ratio of container which regraded as high space.
	// High space means there is a lot of spare capacity, and container resource score varies directly with used size.
	HighSpaceRatio float64 `toml:"high-space-ratio" json:"high-space-ratio"`
	// ResourceScoreFormulaVersion is used to control the formula used to calculate resource score.
	ResourceScoreFormulaVersion string `toml:"resource-score-formula-version" json:"resource-score-formula-version"`
	// SchedulerMaxWaitingOperator is the max coexist operators for each scheduler.
	SchedulerMaxWaitingOperator uint64 `toml:"scheduler-max-waiting-operator" json:"scheduler-max-waiting-operator"`

	// EnableRemoveDownReplica is the option to enable replica checker to remove down replica.
	EnableRemoveDownReplica bool `toml:"enable-remove-down-replica" json:"enable-remove-down-replica,string"`
	// EnableReplaceOfflineReplica is the option to enable replica checker to replace offline replica.
	EnableReplaceOfflineReplica bool `toml:"enable-replace-offline-replica" json:"enable-replace-offline-replica,string"`
	// EnableMakeUpReplica is the option to enable replica checker to make up replica.
	EnableMakeUpReplica bool `toml:"enable-make-up-replica" json:"enable-make-up-replica,string"`
	// EnableRemoveExtraReplica is the option to enable replica checker to remove extra replica.
	EnableRemoveExtraReplica bool `toml:"enable-remove-extra-replica" json:"enable-remove-extra-replica,string"`
	// EnableLocationReplacement is the option to enable replica checker to move replica to a better location.
	EnableLocationReplacement bool `toml:"enable-location-replacement" json:"enable-location-replacement,string"`
	// EnableDebugMetrics is the option to enable debug metrics.
	EnableDebugMetrics bool `toml:"enable-debug-metrics" json:"enable-debug-metrics,string"`
	// EnableJointConsensus is the option to enable using joint consensus as a operator step.
	EnableJointConsensus bool `toml:"enable-joint-consensus" json:"enable-joint-consensus,string"`

	// Schedulers support for loading customized schedulers
	Schedulers SchedulerConfigs `toml:"schedulers" json:"schedulers-v2"` // json v2 is for the sake of compatible upgrade

	// Only used to display
	SchedulersPayload map[string]interface{} `toml:"schedulers-payload" json:"schedulers-payload"`

	// ContainerLimitMode can be auto or manual, when set to auto,
	// Prophet tries to change the container limit values according to
	// the load state of the cluster dynamically. User can
	// overwrite the auto-tuned value by pd-ctl, when the value
	// is overwritten, the value is fixed until it is deleted.
	// Default: manual
	ContainerLimitMode string `toml:"container-limit-mode" json:"container-limit-mode"`
}

type SchedulerConfig struct {
	Type        string   `toml:"type" json:"type"`
	Args        []string `toml:"args" json:"args"`
	Disable     bool     `toml:"disable" json:"disable"`
	ArgsPayload string   `toml:"args-payload" json:"args-payload"`
}

type SchedulerConfigs []SchedulerConfig