devicering

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

type BuilderNode interface {
	Node
	SetActive(value bool)
	SetCapacity(value uint32)
	SetTier(level int, value string)
	ReplaceTiers(tiers []string)
	SetAddress(index int, value string)
	ReplaceAddresses(addrs []string)
	SetMeta(value string)
	SetConfig(config []byte)
}

type Node interface {
	// ID uniquely identifies this node; it will be non-zero as zero is used to
	// indicate "no node".
	ID() uint64
	// Active indicates whether the node should be in use or not. Nodes may be
	// deactivated for a while (during a maintenance, for example) and then
	// reactivated later. While deactivated, the builder will reassign all data
	// previously assigned to the node.
	Active() bool
	// Capacity indicates the amount of data that should be assigned to a node
	// relative to other nodes. It can be in any unit of designation as long as
	// all nodes use the same designation. Most commonly this is the number of
	// gigabytes the node can store, but could be based on CPU capacity or
	// another resource if that makes more sense to balance.
	Capacity() uint32
	// Tiers indicate the layout of the node with respect to other nodes. For
	// example, the lowest tier, tier 0, might be the server ip (where each
	// node represents a drive on that server). The next tier, 1, might then be
	// the power zone the server is in. The number of tiers is flexible, so
	// later an additional tier for geographic region could be added.
	Tiers() []string
	// Tier returns just the single tier value for the level.
	Tier(level int) string
	// Addresses give location information for the node; probably something
	// like ip:port. This is a list for those use cases where different
	// processes use different networks (such as replication using a
	// replication-only network).
	Addresses() []string
	// Address returns just the single address for the index.
	Address(index int) string
	// Meta is additional information for the node; not defined or used by the
	// builder or ring directly.
	Meta() string
	// Config contains the raw configuration bytes for this node.
	Config() []byte
}

type NodeSlice []Node

type Ring interface {
	// Version is the time.Now().UnixNano() of when the Ring data was
	// established.
	//
	// Version can indicate changes in ring data; for example, if a server is
	// currently working with one version of ring data and receives requests
	// that are based on a lesser version of ring data, it can ignore those
	// requests or send an "obsoleted" response or something along those lines.
	// Similarly, if the server receives requests for a greater version of ring
	// data, it can ignore those requests or try to obtain a newer ring
	// version.
	Version() int64
	// Config returns the raw encoded global configuration. This configuration
	// data isn't used by the ring itself, but can be useful in storing
	// configuration data for users of the ring.
	Config() []byte
	// Node returns the node instance identified, if there is one.
	Node(nodeID uint64) Node
	// Nodes returns a NodeSlice of the nodes the Ring references.
	Nodes() NodeSlice
	// NodeCount returns the number of nodes the Ring references.
	NodeCount() int
	// Tiers returns the tier values in use at each level. Note that an empty
	// string is always an available value at any level, although it is not
	// returned from this method.
	Tiers() [][]string
	// PartitionBitCount is the number of bits that can be used to determine a
	// partition number for the current data in the ring. For example, to
	// convert a uint64 hash value into a partition number you could use
	// hashValue >> (64 - ring.PartitionBitCount()). The PartitionBitCount also
	// indicates how many partitions the Ring has; for example, a value of 16
	// would indicate 2**16 or 65,536 partitions.
	PartitionBitCount() uint16
	// ReplicaCount specifies how many replicas the Ring has.
	ReplicaCount() int
	// LocalNode returns the node the ring is locally bound to, if any. This
	// local node binding is used by things such as MsgRing to know what items
	// are bound for the local instance or need to be sent to remote ones, etc.
	LocalNode() Node
	// SetLocalNode sets the node the ring is locally bound to, if any. This
	// local node binding is used by things such as MsgRing to know what items
	// are bound for the local instance or need to be sent to remote ones, etc.
	SetLocalNode(nodeID uint64)
	// Responsible will return true if LocalNode is set and one of the
	// partition's replicas is assigned to that local node.
	//
	// Note that the partition value is not bounds checked; an invalid
	// partition will cause a panic. See the documentation for the Ring
	// interface itself for further discussion.
	Responsible(partition uint32) bool
	// ResponsibleReplica will return the replica index >= 0 if LocalNode is
	// set and one of the partition's replicas is assigned to that local node;
	// it will return -1 if LocalNode is not responsible for the partition.
	//
	// Note that the partition value is not bounds checked; an invalid
	// partition will cause a panic. See the documentation for the Ring
	// interface itself for further discussion.
	ResponsibleReplica(partition uint32) int
	// ResponsibleNodes will return the list of nodes that are responsible for
	// the replicas of the partition.
	//
	// Note that the partition value is not bounds checked; an invalid
	// partition will cause a panic. See the documentation for the Ring
	// interface itself for further discussion.
	ResponsibleNodes(partition uint32) NodeSlice
	// Stats gives information about the ring and its health; the MaxUnder and
	// MaxOver values specifically indicate how balanced the ring is.
	Stats() *Stats
	// Persist saves the Ring state to the given Writer for later reloading via
	// the LoadRing method.
	Persist(w io.Writer) error
}

type Stats struct {
	ReplicaCount      int
	ActiveNodeCount   int
	InactiveNodeCount int
	PartitionBitCount uint16
	PartitionCount    int
	ActiveCapacity    uint64
	InactiveCapacity  uint64
	// MaxUnderNodePercentage is the percentage a node is underweight, or has
	// less data assigned to it than its capacity would indicate it desires.
	MaxUnderNodePercentage float64
	MaxUnderNodeID         uint64
	// MaxOverNodePercentage is the percentage a node is overweight, or has
	// more data assigned to it than its capacity would indicate it desires.
	MaxOverNodePercentage float64
	MaxOverNodeID         uint64
}