cluster

type ClusterAddNodeBody struct {
	NodeID     uint64
	NodeConfig NodeConfig
}

type ClusterAddRelayBody struct {
	RelayID string
}

type ClusterAddSiteBody struct {
	SiteID string
}

type ClusterCommand struct {
	Type        ClusterCommandType
	SubmitterID uint64
	CommandID   uint64
	Data        []byte
}

type ClusterCommandType int

type ClusterConfigController interface {
	LogDump() (raftpb.Snapshot, []raftpb.Entry, error)
	AddNode(ctx context.Context, nodeConfig NodeConfig) error
	ReplaceNode(ctx context.Context, replacedNodeID uint64, replacementNodeID uint64) error
	RemoveNode(ctx context.Context, nodeID uint64) error
	ClusterCommand(ctx context.Context, commandBody interface{}) error
	OnLocalUpdates(cb func(deltas []ClusterStateDelta))
	OnClusterSnapshot(cb func(snapshotIndex uint64, snapshotId string))
	ClusterController() *ClusterController
	Start() error
	Stop()
	CancelProposals()
}

type ClusterConfigControllerBuilder interface {
	SetCreateNewCluster(b bool) ClusterConfigControllerBuilder
	SetLocalNodeAddress(peerAddress PeerAddress) ClusterConfigControllerBuilder
	SetRaftNodeStorage(raftStorage RaftNodeStorage) ClusterConfigControllerBuilder
	SetRaftNodeTransport(transport *TransportHub) ClusterConfigControllerBuilder
	Create() ClusterConfigController
}

type ClusterController struct {
	LocalNodeID          uint64
	State                ClusterState
	PartitioningStrategy PartitioningStrategy
	LocalUpdates         chan []ClusterStateDelta
	// contains filtered or unexported fields
}

type ClusterMoveRelayBody struct {
	RelayID string
	SiteID  string
}

type ClusterRemoveNodeBody struct {
	NodeID            uint64
	ReplacementNodeID uint64
}

type ClusterRemoveRelayBody struct {
	RelayID string
}

type ClusterRemoveSiteBody struct {
	SiteID string
}

type ClusterSetPartitionCountBody struct {
	Partitions uint64
}

type ClusterSetReplicationFactorBody struct {
	ReplicationFactor uint64
}

type ClusterSettings struct {
	// The replication factor of this cluster
	ReplicationFactor uint64
	// The number of partitions in the hash space
	Partitions uint64
}

type ClusterSnapshotBody struct {
	UUID string
}

type ClusterState struct {
	// A set of nodes IDs of nodes that were previously cluster members
	// but were since removed
	RemovedNodes map[uint64]bool
	// Ring members and their configuration
	Nodes map[uint64]*NodeConfig
	// A mapping between tokens and the node that owns them
	Tokens []uint64
	// The partition replicas in this node
	Partitions [][]*PartitionReplica
	// Global cluster settings that must be initialized before the cluster is
	// initialized
	ClusterSettings ClusterSettings
	Sites           map[string]bool
	Relays          map[string]string
}

type ClusterStateDelta struct {
	Type  ClusterStateDeltaType
	Delta interface{}
}

type ClusterStateDeltaRange []ClusterStateDelta

type ClusterStateDeltaType int

type ClusterTakePartitionReplicaBody struct {
	Partition uint64
	Replica   uint64
	NodeID    uint64
}

type ClusterUpdateNodeBody struct {
	NodeID     uint64
	NodeConfig NodeConfig
}

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

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

type NodeAdd struct {
	NodeID     uint64
	NodeConfig NodeConfig
}

type NodeAddress struct {
	NodeID  uint64
	Address ddbRaft.PeerAddress
}

type NodeConfig struct {
	// The network address of the node
	Address ddbRaft.PeerAddress
	// Node capacity in bytes
	Capacity uint64
	// The tokens owned by this node
	Tokens map[uint64]bool
	// a set of partition replicas owned by this node
	OwnedPartitionReplicas map[uint64]map[uint64]bool
	// a set of partition replicas held by this node. This is derived from the cluster state and is used
	// only internally for quick lookup. It is not stored or transferred as part of a node's configuration
	PartitionReplicas map[uint64]map[uint64]bool
}

type NodeConfigList []NodeConfig

type NodeGainPartitionReplica struct {
	NodeID    uint64
	Partition uint64
	Replica   uint64
}

type NodeGainPartitionReplicaOwnership struct {
	NodeID    uint64
	Partition uint64
	Replica   uint64
}

type NodeGainToken struct {
	NodeID uint64
	Token  uint64
}

type NodeLosePartitionReplica struct {
	NodeID    uint64
	Partition uint64
	Replica   uint64
}

type NodeLosePartitionReplicaOwnership struct {
	NodeID    uint64
	Partition uint64
	Replica   uint64
}

type NodeLoseToken struct {
	NodeID uint64
	Token  uint64
}

type NodeRemove struct {
	NodeID uint64
}

type NodeTokenCount struct {
	NodeID     uint64
	TokenCount int
}

type NodeTokenCountHeap []NodeTokenCount

type PartitionReplica struct {
	// The partition number. The partition number combined with the total number of partitions and the range of the hash
	// space define a contiguous range in the hash space for which this partition is responsible
	Partition uint64
	// The index of this partition replica. If the replication factor is set to 3 this number will range from 0 to 2
	// The 0th partition replica represents the primary replica for that partition. The owner of the primary replica
	// will be the only node able to accept writes for this partition. The other replicas for this partition serve
	// only as backups
	Replica uint64
	// The ID of the node that holds this partition replica. The holder can differ from the owner if the cluster is in
	// a transitional state and the partition replica is being transferred to a new node. The owner is based only on
	// the current token assignments
	Holder uint64
	// The ID of the node that owns this partition
	Owner uint64
}

type PartitioningStrategy interface {
	AssignTokens(nodes []NodeConfig, currentTokenAssignment []uint64, partitions uint64) ([]uint64, error)
	AssignPartitions(nodes []NodeConfig, currentPartitionAssignment [][]uint64)
	Owners(tokenAssignment []uint64, partition uint64, replicationFactor uint64) []uint64
	Partition(key string, partitionCount uint64) uint64
}

type RelayAdded struct {
	RelayID string
}

type RelayMoved struct {
	RelayID string
	SiteID  string
}

type RelayRemoved struct {
	RelayID string
}

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

type SiteAdded struct {
	SiteID string
}

type SiteRemoved struct {
	SiteID string
}