funk

type Cluster interface {
	// NodeID is the local cluster node's ID
	NodeID() string

	// Name returns the cluster's name
	Name() string

	// Start launches the cluster, ie joins a Serf cluster and announces its
	// presence
	Start() error

	// Stop stops the cluster
	Stop()

	// Role is the current role of the node
	Role() NodeRole

	// State is the current cluster state
	State() NodeState

	// Events returns an event channel for the cluster. The channel will
	// be closed when the cluster is stopped. Events are for information only
	Events() <-chan Event

	// Leader returns the node ID of the leader in the cluster. If no leader
	// is currently elected it will return a blank string.
	Leader() string

	// Nodes returns a list of the node IDs of each member
	Nodes() []string

	// GetEndpoint returns the endpoint for a particular node. If the node
	// or endpoint isn't found it will return a blank. The endpoint is
	// retrieved from the Serf cluster. Note that there's no guarantee
	// that the node will be responding on that endpoint.
	GetEndpoint(nodeID string, endpointName string) string

	// NewObserver returns a new endpoint observer for endpoints in and around
	// the cluster
	NewObserver() EndpointObserver

	// Created returns the time the cluster was created. This is set when the
	// cluster is bootstrapped.
	Created() time.Time

	EndpointRegistrator
}

type ClusterWatchdog struct {
	Callback     func()
	Timeout      time.Duration
	PollInterval time.Duration
}

type Endpoint struct {
	NodeID        string // NodeID is the ID of the node that registered the endpoint
	ListenAddress string // ListenAddress is the registered address for the endpoint
	Name          string // Name is the name of the endpoint
	Active        bool   // Active is set to true if the endpoint is from an active node
}

type EndpointObserver interface {
	// Observe returns a channel that will send newly discovered endpoints. The
	// channel is closed when the observer shuts down. The consumers should read
	// the channel as soon as possible.
	Observe() <-chan Endpoint

	// Unobserve turns off observation for the channel
	Unobserve(<-chan Endpoint)

	// Shutdown closes all observer channels
	Shutdown()

	// Endpoints returns the entire list of endpoints. Inactive endpoints are
	// omitted.
	Endpoints() []Endpoint

	// Find returns matching endpoints
	Find(name string) []Endpoint

	// FindEndpoint returns the first partially or complete matching endpoint.
	FindFirst(name string) (Endpoint, error)
}

type EndpointRegistrator interface {
	// Register an endpoint.
	RegisterEndpoint(name string, listenAddress string, protocol ProtocolType) error
}

type Event struct {
	State NodeState // State is the state of the local cluster node
	Role  NodeRole  // Role is the role (leader, follower...) of the local cluster node
}

type GRPCServerParameters struct {
	Endpoint string `kong:"help='Server endpoint'"`
	TLS      bool   `kong:"help='Enable TLS'"`
	CertFile string `kong:"help='Certificate file',type='existingfile'"`
	KeyFile  string `kong:"help='Certificate key file',type='existingfile'"`
}

type LeaderChangedEvent struct {
}

type LeaderLostEvent struct {
}

type LocalNodeStoppedEvent struct {
}

type LogMessage struct {
	MessageType LogMessageType
	AckEndpoint string
	Index       uint64
	Data        []byte
}

type LogMessageType byte

type Node struct {
	ID     string
	State  string
	Leader bool
}

type NodeAddedEvent struct {
}

type NodeEvent struct {
	Event SerfEventType
	Node  SerfMember
}

type NodeRemovedEvent struct {
}

type NodeRetiredEvent struct {
}

type NodeRole int32

type NodeState int32

type Parameters struct {
	AutoJoin       bool                 `kong:"help='Auto join via SerfEvents',default='true'"`
	Name           string               `kong:"help='Cluster name',default='clusterfunk'"`
	Interface      string               `kong:"help='Interface address for services'"`
	Verbose        bool                 `kong:"help='Verbose logging for Serf and Raft'"`
	NodeID         string               `kong:"help='Node ID for Serf and Raft',default=''"`
	ZeroConf       bool                 `kong:"help='Zero-conf startup',default='true'"`
	NonVoting      bool                 `kong:"help='Nonvoting node',default='false'"`
	NonMember      bool                 `kong:"help='Non-member',default='false'"`
	AckTimeout     time.Duration        `kong:"help='Ack timeout for nodes in the cluster',default='500ms'"`
	Metrics        string               `kong:"help='Metrics sink to use',enum='blackhole,prometheus',default='prometheus'"`
	Raft           RaftParameters       `kong:"embed,prefix='raft-'"`
	Serf           SerfParameters       `kong:"embed,prefix='serf-'"`
	Management     GRPCServerParameters `kong:"embed,prefix='management-'"`
	LeaderEndpoint string               // This isn't a parameter, it's set by the service
}

type ProtocolType int

type RaftEventType int

type RaftNode interface {

	// Start launches the node. The return value is set to true if the cluster
	// is bootstrapped
	Start(nodeID string, cfg RaftParameters) (bool, error)

	// Stop stops the node. If the removeWhenStopping flag is set and the server is
	// the leader it will remove itself.
	Stop(removeWhenStopping bool) error

	// LocalNodeID returns the local node ID
	LocalNodeID() string

	// AddClusterNode adds a new node to the cluster. Must be leader to perform this operation.
	AddClusterNode(nodeID string, endpoint string) error

	// RemoveClusterNode removes a node from the cluster. Must be leader to perform this
	// operation.
	RemoveClusterNode(nodeID string, endpoint string) error

	// Endpoint returns the Raft endpoint (aka bind address)
	Endpoint() string

	// Leader returns true if this node is the leader. This will verify the
	// leadership with the Raft library.
	Leader() bool

	// AppendLogEntry appends a log entry to the log. The function returns when
	// there's a quorum in the cluster
	AppendLogEntry(data []byte) (uint64, error)

	// LastLogIndex returns the last log index received
	LastLogIndex() uint64

	// Events returns the event channel. There is only one
	// event channel so use multiple listeners at your own peril.
	// You will get NodeAdded, NodeRemoved, LeaderLost and LeaderChanged
	// events on this channel.
	Events() <-chan RaftEventType

	// GetLogMessages returns the replicated log message with the
	// specified type ID
	GetLogMessages(startingIndex uint64) []LogMessage

	// StepDown steps down as a leader if this is the leader node
	StepDown() error

	// RefreshNodes refreshes the node list by reading the Raft configuration.
	// If any events are skipped by the Raft library we'll get the appropriate
	// events and an updated node list after this call.
	RefreshNodes()

	// EnableNode enables a node that has been disabled. The node might be a part of the
	// cluster but not available.
	EnableNode(id string)

	// DisableNode disables a node (in reality removing it from the local node list
	// but it is still a member of the Raft cluster)
	DisableNode(id string)

	// LeaderNodeID returns the Node ID for the leader
	LeaderNodeID() string

	// Nodes returns a list of nodes
	Nodes() *toolbox.StringSet

	MemberList() ([]Node, error)
}

type RaftParameters struct {
	Endpoint   string     `kong:"help='Endpoint for Raft',default=''"`
	DiskStore  string     `kong:"help='Disk-based store',default=''"`
	Bootstrap  bool       `kong:"help='Bootstrap a new Raft cluster',default='true'"`
	Verbose    bool       `kong:"help='Verbose Raft logging',default='false'"`
	TimingMode TimingType `kong:"help='Timing mode',default='default',enum='aggressive,medium,default'"`
	DebugLog   bool       `kong:"help='Show debug log messages for Raft',default='false'"`
}

type SerfEventType int

type SerfMember struct {
	NodeID string
	State  string
	Tags   map[string]string
}

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

type SerfParameters struct {
	Endpoint     string   `kong:"help='Endpoint for Serf',default=''"`
	JoinAddress  []string `kong:"help='Join address and port for Serf cluster'"`
	Verbose      bool     `kong:"help='Verbose logging for Serf'"`
	SnapshotPath string   `kong:"help='Snapshot path (for persistence)'"`
}

type ServiceNode interface {
	RegisterServiceEndpoint(endpointName string, listenAddress string) error
	Stop()
}

type ServiceParameters struct {
	Name     string         `kong:"help='Cluster name',default='clusterfunk'"`
	NodeID   string         `kong:"help='Node ID for Serf node',default=''"`
	Verbose  bool           `kong:"help='Verbose logging for Serf and Raft'"`
	ZeroConf bool           `kong:"help='Zero-conf startup',default='true'"`
	Serf     SerfParameters `kong:"embed,prefix='serf-'"`
}

type TimingType string