cluster

type ClusterMetaInfo struct {
	MaxGID   int64
	MaxRegID uint64
}

type CommonCoordErr struct {
	CoordErr
}

type ConsistentStore interface {
	WriteKey(key, value string) error
	ReadKey(key string) (string, error)
	ListKey(key string) ([]string, error)
}

type CoordErr struct {
	ErrMsg  string
	ErrCode ErrRPCRetCode
	ErrType CoordErrType
}

type CoordErrStats struct {
	sync.Mutex
	CoordErrStatsData
}

type CoordErrStatsData struct {
	NamespaceCoordMissingError int64
	LocalErr                   int64
	OtherCoordErrs             map[string]int64
}

type CoordErrType int

type CoordStats struct {
	ErrStats     CoordErrStatsData
	NsCoordStats []NamespaceCoordStat `json:"ns_coord_stats"`
}

type DNEtcdRegister struct {
	*EtcdRegister
	sync.Mutex
	// contains filtered or unexported fields
}

type DataNodeRegister interface {
	Register
	// check the learner role before register, should never change the role
	Register(nodeData *NodeInfo) error // update
	Unregister(nodeData *NodeInfo) error
	// get the newest pd leader and watch the change of it.
	WatchPDLeader(leader chan *NodeInfo, stop chan struct{}) error
	GetNodeInfo(nid string) (NodeInfo, error)
	// while losing leader, update to empty nid
	// while became the new leader, update to my node
	UpdateNamespaceLeader(ns string, partition int, rl RealLeader, oldGen EpochType) (EpochType, error)
	GetNamespaceLeader(ns string, partition int) (string, EpochType, error)
	NewRegisterNodeID() (uint64, error)
}

type EVENT_TYPE int

type EpochType int64

type ErrRPCRetCode int

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

type EtcdLock struct {
	sync.Mutex
	// contains filtered or unexported fields
}

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

type ISRStat struct {
	HostName string `json:"hostname"`
	NodeID   string `json:"node_id"`
}

type Master interface {
	Start()
	Stop()
	GetEventsChan() <-chan *MasterEvent
	GetKey() string
	GetMaster() string
}

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

type MasterEvent struct {
	Type          EVENT_TYPE
	Master        string
	ModifiedIndex uint64
}

type NamespaceCoordStat struct {
	Node      string    `json:"node"`
	Name      string    `json:"name"`
	Partition int       `json:"partition"`
	ISRStats  []ISRStat `json:"isr_stats"`
}

type NamespaceMetaInfo struct {
	PartitionNum int
	Replica      int
	// to verify the data of the create -> delete -> create with same namespace
	MagicCode int64
	MinGID    int64

	EngType          string
	OptimizedFsync   bool
	SnapCount        int
	Tags             map[string]interface{}
	ExpirationPolicy string
	DataVersion      string
	// contains filtered or unexported fields
}

type NamespaceNameInfo struct {
	NamespaceName      string
	NamespacePartition int
}

type NodeInfo struct {
	RegID             uint64
	ID                string
	NodeIP            string
	Hostname          string
	RedisPort         string
	HttpPort          string
	RpcPort           string
	RaftTransportAddr string
	Version           string
	Tags              map[string]interface{}
	DataRoot          string
	RsyncModule       string
	LearnerRole       string
	// contains filtered or unexported fields
}

type Options struct {
	AutoBalanceAndMigrate bool
	BalanceStart          int
	BalanceEnd            int
	BalanceVer            string
	DataDir               string
	FilterNamespaces      string
}

type PDEtcdRegister struct {
	*EtcdRegister
	// contains filtered or unexported fields
}

type PDRegister interface {
	Register
	Register(nodeData *NodeInfo) error // update
	Unregister(nodeData *NodeInfo) error
	// the cluster root modify index
	GetClusterEpoch() (EpochType, error)
	GetClusterMetaInfo() (ClusterMetaInfo, error)
	AcquireAndWatchLeader(leader chan *NodeInfo, stop chan struct{})

	GetDataNodes() ([]NodeInfo, error)
	// watching the cluster data node, should return the newest for the first time.
	WatchDataNodes(nodeC chan []NodeInfo, stopC chan struct{})
	// create and write the meta info to meta node
	CreateNamespace(ns string, meta *NamespaceMetaInfo) error
	UpdateNamespaceMetaInfo(ns string, meta *NamespaceMetaInfo, oldGen EpochType) error
	// create partition path
	CreateNamespacePartition(ns string, partition int) error
	IsExistNamespace(ns string) (bool, error)
	IsExistNamespacePartition(ns string, partition int) (bool, error)
	DeleteNamespacePart(ns string, partition int) error
	DeleteWholeNamespace(ns string) error
	//
	// update the replica info about replica node list, epoch for partition
	// Note: update should do check-and-set to avoid unexpected override.
	// the epoch in replicaInfo should be updated to the new epoch
	// if no partition, replica info node should create only once.
	UpdateNamespacePartReplicaInfo(ns string, partition int, replicaInfo *PartitionReplicaInfo, oldGen EpochType) error
	PrepareNamespaceMinGID() (int64, error)
	UpdateNamespaceSchema(ns string, table string, schema *SchemaInfo) error
}

type PartitionMetaInfo struct {
	Name      string
	Partition int

	NamespaceMetaInfo
	PartitionReplicaInfo
	// contains filtered or unexported fields
}

type PartitionReplicaInfo struct {
	RaftNodes    []string
	RaftIDs      map[string]uint64
	Removings    map[string]RemovingInfo
	MaxRaftID    int64
	LearnerNodes map[string][]string
	// contains filtered or unexported fields
}

type RealLeader struct {
	Leader string
	// contains filtered or unexported fields
}

type Register interface {
	InitClusterID(id string)
	Start()
	// all registered pd nodes.
	GetAllPDNodes() ([]NodeInfo, error)
	// should return both the meta info for namespace and the replica info for partition
	// epoch should be updated while return
	GetNamespacePartInfo(ns string, partition int) (*PartitionMetaInfo, error)
	// get directly from register without cache
	GetRemoteNamespaceReplicaInfo(ns string, partition int) (*PartitionReplicaInfo, error)
	// get  meta info only
	GetNamespaceMetaInfo(ns string) (NamespaceMetaInfo, error)
	GetNamespaceInfo(ns string) ([]PartitionMetaInfo, error)
	GetAllNamespaces() (map[string]map[int]PartitionMetaInfo, EpochType, error)
	GetNamespacesNotifyChan() chan struct{}
	GetNamespaceSchemas(ns string) (map[string]SchemaInfo, error)
	GetNamespaceTableSchema(ns string, table string) (*SchemaInfo, error)
	// the saved key should have the node info prefix to avoid conflict with each other data node
	// if it is designed to shared between data node, should use carefully with concurrent modify
	// note: the data key will be under the cluster root data path
	SaveKV(key string, value string) error
	GetKV(key string) (string, error)
	Stop()
}

type RemovingInfo struct {
	RemoveTime      int64
	RemoveReplicaID uint64
}

type SchemaInfo struct {
	Schema []byte
	Epoch  EpochType
}