pdserver

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

type CellInfo struct {
	Meta         metapb.Cell
	LeaderPeer   *metapb.Peer
	DownPeers    []pdpb.PeerStats
	PendingPeers []metapb.Peer
}

type Cfg struct {
	Name                     string
	DataPath                 string
	AddrRPC                  string
	DurationLeaderLease      int64
	DurationHeartbeatWatcher time.Duration
	ThresholdPauseWatcher    int

	URLsClient          string
	URLsAdvertiseClient string
	URLsPeer            string
	URLsAdvertisePeer   string
	InitialCluster      string
	InitialClusterState string

	// The label keys specified the location of a store.
	// 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.
	LabelsLocation []string
	// LimitReplicas is the number of replicas for each cell.
	LimitReplicas uint32
	// If the snapshot count of one store is greater than this value,
	// it will never be used as a source or target store.
	LimitSnapshots uint64
	// MaxStoreDownTime is the max duration after which
	// a store will be considered to be down if it hasn't reported heartbeats.
	LimitStoreDownDuration time.Duration
	// LimitScheduleLeader is the max coexist leader schedules.
	LimitScheduleLeader uint64
	// LimitScheduleCell is the max coexist cell schedules.
	LimitScheduleCell uint64
	// LimitScheduleReplica is the max coexist replica schedules.
	LimitScheduleReplica uint64
	// ThresholdStorageRate is the max storage rate of used for schduler
	ThresholdStorageRate int
}

type ClusterInfo struct {
	Meta metapb.Cluster `json:"meta"`
}

type ClusterStore interface {
	SetInitParams(clusterID uint64, params string) error
	GetInitParams(clusterID uint64) ([]byte, error)
	GetCurrentClusterMembers() (*clientv3.MemberListResponse, error)
	GetClusterID() (uint64, error)
	CreateFirstClusterID() (uint64, error)
	SetClusterBootstrapped(clusterID uint64, cluster metapb.Cluster, store metapb.Store, cells []metapb.Cell) (bool, error)
	LoadClusterMeta(clusterID uint64) (*metapb.Cluster, error)
	LoadStoreMeta(clusterID uint64, limit int64, do func(metapb.Store)) error
	LoadCellMeta(clusterID uint64, limit int64, do func(metapb.Cell)) error
	LoadWatchers(clusterID uint64, limit int64, do func(pdpb.Watcher)) error
	SetStoreMeta(clusterID uint64, store metapb.Store) error
	SetCellMeta(clusterID uint64, cell metapb.Cell) error
	SetWatchers(clusterID uint64, watcher pdpb.Watcher) error
}

type Filter interface {
	FilterSource(store *StoreInfo) bool
	FilterTarget(store *StoreInfo) bool
}

type IDStore interface {
	GetID() (uint64, error)
	CreateID(leaderSignature string, value uint64) error
	UpdateID(leaderSignature string, old, value uint64) error
}

type IndexStore interface {
	ListIndex() (idxDefs []*pdpb.IndexDef, err error)
	GetIndex(id string) (idxDef *pdpb.IndexDef, err error)
	CreateIndex(idxDef *pdpb.IndexDef) (err error)
	DeleteIndex(id string) (err error)
}

type LeaderStore interface {
	// CampaignLeader is for leader election
	// if we are win the leader election, the enableLeaderFun will call, otherwrise disableLeaderFun will call
	CampaignLeader(leaderSignature string, leaderLeaseTTL int64, enableLeaderFun, disableLeaderFun func()) error
	// WatchLeader watch leader,
	// this funcation will return unitl the leader's lease is timeout
	// or server closed
	WatchLeader()
	// ResignLeader delete leader itself and let others start a new election again.
	ResignLeader(leaderSignature string) error
	// GetCurrentLeader return current leader
	GetCurrentLeader() (*pdpb.Leader, error)
}

type Operator interface {
	GetCellID() uint64
	GetResourceKind() ResourceKind
	Do(cell *CellInfo) (*pdpb.CellHeartbeatRsp, bool)
}

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

type ReplicationCfg struct {
	sync.RWMutex
	// MaxReplicas is the number of replicas for each cell.
	MaxReplicas uint32 `json:"maxReplicas"`

	// The label keys specified the location of a store.
	// 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 []string `json:"location-labels"`
}

type ResourceKind int

type Scheduler interface {
	GetName() string
	GetResourceKind() ResourceKind
	GetResourceLimit() uint64
	Prepare(cache *cache) error
	Cleanup(cache *cache)
	Schedule(cache *cache) Operator
}

type Selector interface {
	SelectSource(stores []*StoreInfo, filters ...Filter) *StoreInfo
	SelectTarget(stores []*StoreInfo, filters ...Filter) *StoreInfo
}

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

type Store interface {
	ClusterStore
	IDStore
	LeaderStore
	IndexStore

	Close() error
	RawClient() *clientv3.Client
}

type StoreInfo struct {
	Meta   metapb.Store
	Status *StoreStatus
}

type StoreOperator interface {
	GetStoreID() uint64
	Do(store *StoreInfo) (*pdpb.StoreHeartbeatRsp, bool)
}

type StoreStatus struct {
	Stats           *pdpb.StoreStats
	LeaderCount     uint32
	LastHeartbeatTS time.Time
	// contains filtered or unexported fields
}