ring

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 LogFunc func(format string, v ...interface{})

type Msg interface {
	// MsgType is the unique designator for the type of message content (such
	// as a pull replication request, a read request, etc.). Message types just
	// need to be unique values; usually picking 64 bits of a UUID is fine.
	MsgType() uint64
	// MsgLength returns the number of bytes for the content of the message
	// (the amount that will be written with a call to WriteContent).
	MsgLength() uint64
	// WriteContent will send the contents of the message to the given writer.
	//
	// Note that WriteContent may be called multiple times and may be called
	// concurrently.
	//
	// Also note that the content should be written as quickly as possible as
	// any delays may cause the message transmission to be aborted and dropped.
	// In other words, any significant processing to build the message content
	// should be done before the Msg is given to the MsgRing for delivery.
	WriteContent(io.Writer) (uint64, error)
	// Free will be called when the MsgRing no longer has any references to the
	// message and allows the message to free any resources it may have, or be
	// reused, etc.
	Free()
}

type MsgRing interface {
	// Ring returns the ring information used to determine messaging endpoints;
	// note that this method may return nil if no ring information is yet
	// available.
	Ring() Ring
	// MaxMsgLength indicates the maximum number of bytes the content of a
	// message may contain to be handled by this MsgRing.
	MaxMsgLength() uint64
	// SetMsgHandler associates a message type with a handler; any incoming
	// messages with the type will be delivered to the handler. Message types
	// just need to be unique uint64 values; usually picking 64 bits of a UUID
	// is fine.
	SetMsgHandler(msgType uint64, handler MsgUnmarshaller)
	// MsgToNode queues the message for delivery to the indicated node; the
	// timeout should be considered for queueing, not for actual delivery.
	//
	// When the msg has actually been sent or has been discarded due to
	// delivery errors or delays, msg.Free() will be called.
	MsgToNode(msg Msg, nodeID uint64, timeout time.Duration)
	// MsgToNode queues the message for delivery to all other replicas of a
	// partition; the timeout should be considered for queueing, not for actual
	// delivery.
	//
	// If the ring is not bound to a specific node (LocalNode() returns nil)
	// then the delivery attempts will be to all replicas.
	//
	// When the msg has actually been sent or has been discarded due to
	// delivery errors or delays, msg.Free() will be called.
	MsgToOtherReplicas(msg Msg, partition uint32, timeout time.Duration)
}

type MsgUnmarshaller func(reader io.Reader, desiredBytesToRead uint64) (actualBytesRead uint64, err error)

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
}

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

type TCPMsgRingConfig struct {
	// LogCritical sets the func to use for critical messages; these are
	// messages about issues that render the TCPMsgRing ring inoperative.
	// Defaults logging to os.Stderr.
	LogCritical LogFunc
	// LogDebug sets the func to use for debug messages. Defaults not logging
	// debug messages.
	LogDebug LogFunc
	// AddressIndex set the index to use with Node.Address(index) to lookup a
	// Node's TCP address.
	AddressIndex int
	// BufferedMessagesPerAddress indicates how many outgoing Msg instances can
	// be buffered before dropping additional ones. Defaults to 8.
	BufferedMessagesPerAddress int
	// ConnectTimeout indicates how many seconds before giving up on a TCP
	// connection establishment. Defaults to 60 seconds.
	ConnectTimeout int
	// ReconnectInterval indicates how many seconds to wait between connection
	// tries. Defaults to 10 seconds.
	ReconnectInterval int
	// ChunkSize indicates how many bytes to attempt to read at once with each
	// network read. Defaults to 16,384 bytes.
	ChunkSize int
	// WithinMessageTimeout indicates how many seconds before giving up on
	// reading data within a message. Defaults to 5 seconds.
	WithinMessageTimeout int
	// UseTLS enables use of TLS for server and client comms
	UseTLS         bool
	MutualTLS      bool
	SkipVerify     bool
	CustomCertPool bool
	CertFile       string
	KeyFile        string
	CAFile         string
}

type TCPMsgRingStats struct {
	Shutdown                  bool
	RingChanges               int32
	RingChangeCloses          int32
	MsgToNodes                int32
	MsgToNodeNoRings          int32
	MsgToNodeNoNodes          int32
	MsgToOtherReplicas        int32
	MsgToOtherReplicasNoRings int32
	ListenErrors              int32
	IncomingConnections       int32
	Dials                     int32
	DialErrors                int32
	OutgoingConnections       int32
	MsgChanCreations          int32
	MsgToAddrs                int32
	MsgToAddrQueues           int32
	MsgToAddrTimeoutDrops     int32
	MsgToAddrShutdownDrops    int32
	MsgReads                  int32
	MsgReadErrors             int32
	MsgWrites                 int32
	MsgWriteErrors            int32
}