serfer

README

serfer

Serfer is a simple abstraction over Serf event handling

Documentation

Overview

Serfer is a simple library which provides interfaces for handling various Serf events.

This allows for an encapsulation of more complex event processing logic by using separate event handlers based on event type.

Index

• Constants
• type EventHandler
• type IsLeaderFunc
• type LeaderElectionHandler
• type MemberEventHandler
• type MemberFailureHandler
• type MemberJoinHandler
• type MemberLeaveHandler
• type MemberReapHandler
• type MemberUpdateHandler
• type QueryEventHandler
• type Reconciler
• type SerfEventHandler
  • func (s SerfEventHandler) HandleEvent(e serf.Event)
• type Serfer
  • func NewSerfer(c chan serf.Event, handler EventHandler) Serfer
• type UnknownEventHandler
• type UserEventHandler

Constants

const (
	// StatusReap is used to update the status of a node if we
	// are handling a EventMemberReap
	StatusReap = serf.MemberStatus(-1)
)

Types

type EventHandler

type EventHandler interface {
	HandleEvent(serf.Event)
}

EventHandler processes generic Serf events. Depending on the event type, more processing may be needed.

type IsLeaderFunc

type IsLeaderFunc func() bool

IsLeaderFunc should return true if the local node is the cluster leader.

type LeaderElectionHandler

type LeaderElectionHandler interface {
	HandleLeaderElection(serf.UserEvent)
}

LeaderElectionHandler handles leader election events.

type MemberEventHandler

type MemberEventHandler interface {
	HandleMemberEvent(serf.MemberEvent)
}

MemberEventHandler handles membership change events.

type MemberFailureHandler

type MemberFailureHandler interface {
	HandleMemberFailure(serf.MemberEvent)
}

MemberFailureHandler handles member failure events.

type MemberJoinHandler

type MemberJoinHandler interface {
	HandleMemberJoin(serf.MemberEvent)
}

MemberJoinHandler handles member join events.

type MemberLeaveHandler

type MemberLeaveHandler interface {
	HandleMemberLeave(serf.MemberEvent)
}

MemberLeaveHandler handles member leave events.

type MemberReapHandler

type MemberReapHandler interface {
	HandleMemberReap(serf.MemberEvent)
}

MemberReapHandler handles member reap events.

type MemberUpdateHandler

type MemberUpdateHandler interface {
	HandleMemberUpdate(serf.MemberEvent)
}

MemberUpdateHandler handles member update events.

type QueryEventHandler

type QueryEventHandler interface {
	HandleQueryEvent(serf.Query)
}

QueryEventHandler handles Serf query events.

type Reconciler

type Reconciler interface {
	Reconcile(serf.Member)
}

Reconciler is used to reconcile Serf events wilth an external process, like Raft.

type SerfEventHandler

type SerfEventHandler struct {

	// ServicePrefix is used to filter out unknown events.
	ServicePrefix string

	// ReconcileOnJoin determines if the Reconiler is called when a node joins the cluster.
	ReconcileOnJoin bool

	// ReconcileOnLeave determines if the Reconiler is called when a node leaves the cluster.
	ReconcileOnLeave bool

	// ReconcileOnFail determines if the Reconiler is called when a node fails.
	ReconcileOnFail bool

	// ReconcileOnUpdate determines if the Reconiler is called when a node updates.
	ReconcileOnUpdate bool

	// ReconcileOnReap determines if the Reconiler is called when a node is reaped from the cluster.
	ReconcileOnReap bool

	// IsLeader determines if the local node is the cluster leader.
	IsLeader IsLeaderFunc

	// IsLeaderEventFunc determines if an event is a leader election event based on the event name.
	IsLeaderEvent func(string) bool

	// LeaderElectionHandler processes leader election events.
	LeaderElectionHandler LeaderElectionHandler

	// UserEvent processes known, non-leader election events.
	UserEvent UserEventHandler

	// UnknownEventHandler processes unkown events.
	UnknownEventHandler UnknownEventHandler

	// Called when a Member joins the cluster.
	NodeJoined MemberJoinHandler

	// Called when a Member leaves the cluster by sending a leave message.
	NodeLeft MemberLeaveHandler

	// Called when a Member has been detected as failed.
	NodeFailed MemberFailureHandler

	// Called when a Member has been Readed from the cluster.
	NodeReaped MemberReapHandler

	// Called when a Member has been updated.
	NodeUpdated MemberUpdateHandler

	// Called when a membership event occurs.
	Reconciler Reconciler

	// Called when a serf.Query is received.
	QueryHandler QueryEventHandler

	// Logs output
	Logger log.Logger
}

SerfEventHandler is used to dispatch various Serf events to separate event handlers.

func (SerfEventHandler) HandleEvent

func (s SerfEventHandler) HandleEvent(e serf.Event)

HandleEvent processes a generic Serf event and dispatches it to the appropriate destination.

type Serfer

type Serfer interface {

	// Start starts the serfer goroutine.
	Start()

	// Stop stops all event processing and blocks until finished.
	Stop() error
}

Serfer processes Serf.Events and is meant to be ran in a goroutine.

func NewSerfer

func NewSerfer(c chan serf.Event, handler EventHandler) Serfer

NewSerfer returns a new Serfer implementation that uses the given channel and event handlers.

type UnknownEventHandler

type UnknownEventHandler interface {
	HandleUnknownEvent(serf.UserEvent)
}

UnknownEventHandler handles unknown events.

type UserEventHandler

type UserEventHandler interface {
	HandleUserEvent(serf.UserEvent)
}

UserEventHandler handles user events.