agent

package
Version: v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 5, 2013 License: MPL-2.0 Imports: 26 Imported by: 0

Documentation

Index

Constants

View Source
const (
	MinIPCVersion = 1
	MaxIPCVersion = 1
)
View Source
const DefaultBindPort int = 7946

This is the default port that we use for Serf communication

Variables

View Source
var DefaultConfig = &Config{
	BindAddr:     "0.0.0.0",
	LogLevel:     "INFO",
	RPCAddr:      "127.0.0.1:7373",
	Protocol:     serf.ProtocolVersionMax,
	ReplayOnJoin: false,
	Profile:      "lan",
	LeaveOnInt:   true,
}

DefaultConfig contains the defaults for configurations.

Functions

func LevelFilter

func LevelFilter() *logutils.LevelFilter

LevelFilter returns a LevelFilter that is configured with the log levels that we use.

func NewLogWriter added in v0.3.0

func NewLogWriter(buf int) *logWriter

NewLogWriter creates a logWriter with the given buffer capacity

func ValidateLevelFilter

func ValidateLevelFilter(minLevel logutils.LogLevel, filter *logutils.LevelFilter) bool

ValidateLevelFilter verifies that the log levels within the filter are valid.

Types

type Agent

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

Agent starts and manages a Serf instance, adding some niceties on top of Serf such as storing logs that you can later retrieve, and invoking EventHandlers when events occur.

func Create added in v0.3.0

func Create(conf *serf.Config, logOutput io.Writer) (*Agent, error)

Start creates a new agent, potentially returning an error

func (*Agent) DeregisterEventHandler added in v0.3.0

func (a *Agent) DeregisterEventHandler(eh EventHandler)

DeregisterEventHandler removes an EventHandler and prevents more invocations

func (*Agent) ForceLeave added in v0.3.0

func (a *Agent) ForceLeave(node string) error

ForceLeave is used to eject a failed node from the cluster

func (*Agent) Join

func (a *Agent) Join(addrs []string, replay bool) (n int, err error)

Join asks the Serf instance to join. See the Serf.Join function.

func (*Agent) Leave added in v0.3.0

func (a *Agent) Leave() error

Leave prepares for a graceful shutdown of the agent and its processes

func (*Agent) RegisterEventHandler added in v0.3.0

func (a *Agent) RegisterEventHandler(eh EventHandler)

RegisterEventHandler adds an event handler to recieve event notifications

func (*Agent) Serf

func (a *Agent) Serf() *serf.Serf

Returns the Serf agent of the running Agent.

func (*Agent) SerfConfig

func (a *Agent) SerfConfig() *serf.Config

Returns the Serf config of the running Agent.

func (*Agent) Shutdown

func (a *Agent) Shutdown() error

Shutdown closes this agent and all of its processes. Should be preceeded by a Leave for a graceful shutdown.

func (*Agent) ShutdownCh added in v0.3.0

func (a *Agent) ShutdownCh() <-chan struct{}

ShutdownCh returns a channel that can be selected to wait for the agent to perform a shutdown.

func (*Agent) Start

func (a *Agent) Start() error

Start is used to initiate the event listeners. It is seperate from create so that there isn't a race condition between creating the agent and registering handlers

func (*Agent) UserEvent

func (a *Agent) UserEvent(name string, payload []byte, coalesce bool) error

UserEvent sends a UserEvent on Serf, see Serf.UserEvent.

type AgentIPC added in v0.3.0

type AgentIPC struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func NewAgentIPC added in v0.3.0

func NewAgentIPC(agent *Agent, listener net.Listener,
	logOutput io.Writer, logWriter *logWriter) *AgentIPC

NewAgentIPC is used to create a new Agent IPC handler

func (*AgentIPC) Shutdown added in v0.3.0

func (i *AgentIPC) Shutdown()

Shutdown is used to shutdown the IPC layer

type AppendSliceValue

type AppendSliceValue []string

AppendSliceValue implements the flag.Value interface and allows multiple calls to the same variable to append a list.

func (*AppendSliceValue) Set

func (s *AppendSliceValue) Set(value string) error

func (*AppendSliceValue) String

func (s *AppendSliceValue) String() string

type Command

type Command struct {
	Ui         cli.Ui
	ShutdownCh <-chan struct{}
	// contains filtered or unexported fields
}

Command is a Command implementation that runs a Serf agent. The command will not end unless a shutdown message is sent on the ShutdownCh. If two messages are sent on the ShutdownCh it will forcibly exit.

func (*Command) Help

func (c *Command) Help() string

func (*Command) Run

func (c *Command) Run(args []string) int

func (*Command) Synopsis

func (c *Command) Synopsis() string

type Config

type Config struct {
	// All the configurations in this section are identical to their
	// Serf counterparts. See the documentation for Serf.Config for
	// more info.
	NodeName string `mapstructure:"node_name"`
	Role     string `mapstructure:"role"`

	// BindAddr is the address that the Serf agent's communication ports
	// will bind to. Serf will use this address to bind to for both TCP
	// and UDP connections. If no port is present in the address, the default
	// port will be used.
	BindAddr string `mapstructure:"bind"`

	// EncryptKey is the secret key to use for encrypting communication
	// traffic for Serf. The secret key must be exactly 16-bytes, base64
	// encoded. The easiest way to do this on Unix machines is this command:
	// "head -c16 /dev/urandom | base64". If this is not specified, the
	// traffic will not be encrypted.
	EncryptKey string `mapstructure:"encrypt_key"`

	// LogLevel is the level of the logs to output.
	// This can be updated during a reload.
	LogLevel string `mapstructure:"log_level"`

	// RPCAddr is the address and port to listen on for the agent's RPC
	// interface.
	RPCAddr string `mapstructure:"rpc_addr"`

	// Protocol is the Serf protocol version to use.
	Protocol int `mapstructure:"protocol"`

	// ReplayOnJoin tells Serf to replay past user events
	// when joining based on a `StartJoin`.
	ReplayOnJoin bool `mapstructure:"replay_on_join"`

	// StartJoin is a list of addresses to attempt to join when the
	// agent starts. If Serf is unable to communicate with any of these
	// addresses, then the agent will error and exit.
	StartJoin []string `mapstructure:"start_join"`

	// EventHandlers is a list of event handlers that will be invoked.
	// These can be updated during a reload.
	EventHandlers []string `mapstructure:"event_handlers"`

	// Profile is used to select a timing profile for Serf. The supported choices
	// are "wan", "lan", and "local". The default is "lan"
	Profile string `mapstructure:"profile"`

	// SnapshotPath is used to allow Serf to snapshot important transactional
	// state to make a more graceful recovery possible. This enables auto
	// re-joining a cluster on failure and avoids old message replay.
	SnapshotPath string `mapstructure:"snapshot_path"`

	// LeaveOnTerm controls if Serf does a graceful leave when receiving
	// the TERM signal. Defaults false. This can be changed on reload.
	LeaveOnTerm bool `mapstructure:"leave_on_terminate"`

	// LeaveOnInt controls if Serf does a graceful leave when receiving
	// the INT signal. Defaults true. This can be changed on reload.
	LeaveOnInt bool `mapstructure:"leave_on_interrupt"`
}

Config is the configuration that can be set for an Agent. Some of these configurations are exposed as command-line flags to `serf agent`, whereas many of the more advanced configurations can only be set by creating a configuration file.

func DecodeConfig added in v0.2.0

func DecodeConfig(r io.Reader) (*Config, error)

DecodeConfig reads the configuration from the given reader in JSON format and decodes it into a proper Config structure.

func MergeConfig added in v0.2.0

func MergeConfig(a, b *Config) *Config

MergeConfig merges two configurations together to make a single new configuration.

func ReadConfigPaths added in v0.2.0

func ReadConfigPaths(paths []string) (*Config, error)

ReadConfigPaths reads the paths in the given order to load configurations. The paths can be to files or directories. If the path is a directory, we read one directory deep and read any files ending in ".json" as configuration files.

func (*Config) BindAddrParts

func (c *Config) BindAddrParts() (string, int, error)

BindAddrParts returns the parts of the BindAddr that should be used to configure Serf.

func (*Config) EncryptBytes added in v0.2.0

func (c *Config) EncryptBytes() ([]byte, error)

EncryptBytes returns the encryption key configured.

func (*Config) EventScripts

func (c *Config) EventScripts() []EventScript

EventScripts returns the list of EventScripts associated with this configuration and specified by the "event_handlers" configuration.

type EventFilter added in v0.3.0

type EventFilter struct {
	Event     string
	UserEvent string
}

EventFilter is used to filter which events are processed

func ParseEventFilter added in v0.3.0

func ParseEventFilter(v string) []EventFilter

ParseEventFilter a string with the event type filters and parses it into a series of EventFilters if it can.

func (*EventFilter) Invoke added in v0.3.0

func (s *EventFilter) Invoke(e serf.Event) bool

Invoke tests whether or not this event script should be invoked for the given Serf event.

func (*EventFilter) Valid added in v0.3.0

func (s *EventFilter) Valid() bool

Valid checks if this is a valid agent event script.

type EventHandler

type EventHandler interface {
	HandleEvent(serf.Event)
}

EventHandler is a handler that does things when events happen.

type EventScript

type EventScript struct {
	EventFilter
	Script string
}

EventScript is a single event script that will be executed in the case of an event, and is configured from the command-line or from a configuration file.

func ParseEventScript

func ParseEventScript(v string) []EventScript

ParseEventScript takes a string in the format of "type=script" and parses it into an EventScript struct, if it can.

func (*EventScript) String

func (s *EventScript) String() string

type GatedWriter

type GatedWriter struct {
	Writer io.Writer
	// contains filtered or unexported fields
}

GatedWriter is an io.Writer implementation that buffers all of its data into an internal buffer until it is told to let data through.

func (*GatedWriter) Flush

func (w *GatedWriter) Flush()

Flush tells the GatedWriter to flush any buffered data and to stop buffering.

func (*GatedWriter) Write

func (w *GatedWriter) Write(p []byte) (n int, err error)

type IPCClient added in v0.3.0

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

func (*IPCClient) Send added in v0.3.0

func (c *IPCClient) Send(header *responseHeader, obj interface{}) error

send is used to send an object using the MsgPack encoding. send is serialized to prevent write overlaps, while properly buffering.

func (*IPCClient) String added in v0.3.0

func (c *IPCClient) String() string

type LogHandler added in v0.3.0

type LogHandler interface {
	HandleLog(string)
}

LogHandler interface is used for clients that want to subscribe to logs, for example to stream them over an IPC mechanism

type Member added in v0.3.0

type Member struct {
	Name        string
	Addr        net.IP
	Port        uint16
	Role        string
	Status      string
	ProtocolMin uint8
	ProtocolMax uint8
	ProtocolCur uint8
	DelegateMin uint8
	DelegateMax uint8
	DelegateCur uint8
}

type MockEventHandler

type MockEventHandler struct {
	Events []serf.Event
	sync.Mutex
}

MockEventHandler is an EventHandler implementation that can be used for tests.

func (*MockEventHandler) HandleEvent

func (h *MockEventHandler) HandleEvent(e serf.Event)

type RPCClient

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

RPCClient is the RPC client to make requests to the agent RPC.

func NewRPCClient added in v0.3.0

func NewRPCClient(addr string) (*RPCClient, error)

NewRPCClient is used to create a new RPC client given the address. This will properly dial, handshake, and start listening

func (*RPCClient) Close

func (c *RPCClient) Close() error

Close is used to free any resources associated with the client

func (*RPCClient) ForceLeave added in v0.2.0

func (c *RPCClient) ForceLeave(node string) error

ForceLeave is used to ask the agent to issue a leave command for a given node

func (*RPCClient) Join

func (c *RPCClient) Join(addrs []string, replay bool) (int, error)

Join is used to instruct the agent to attempt a join

func (*RPCClient) Leave added in v0.3.0

func (c *RPCClient) Leave() error

Leave is used to trigger a graceful leave and shutdown

func (*RPCClient) Members

func (c *RPCClient) Members() ([]Member, error)

Members is used to fetch a list of known members

func (*RPCClient) Monitor

func (c *RPCClient) Monitor(level logutils.LogLevel, ch chan<- string) (StreamHandle, error)

Monitor is used to subscribe to the logs of the agent

func (*RPCClient) Stop added in v0.3.0

func (c *RPCClient) Stop(handle StreamHandle) error

Stop is used to unsubscribe from logs or event streams

func (*RPCClient) Stream added in v0.3.0

func (c *RPCClient) Stream(filter string, ch chan<- map[string]interface{}) (StreamHandle, error)

Stream is used to subscribe to events

func (*RPCClient) UserEvent

func (c *RPCClient) UserEvent(name string, payload []byte, coalesce bool) error

UserEvent is used to trigger sending an event

type ScriptEventHandler

type ScriptEventHandler struct {
	Self    serf.Member
	Scripts []EventScript
	Logger  *log.Logger
	// contains filtered or unexported fields
}

ScriptEventHandler invokes scripts for the events that it receives.

func (*ScriptEventHandler) HandleEvent

func (h *ScriptEventHandler) HandleEvent(e serf.Event)

func (*ScriptEventHandler) UpdateScripts added in v0.3.0

func (h *ScriptEventHandler) UpdateScripts(scripts []EventScript)

UpdateScripts is used to safely update the scripts we invoke in a thread safe manner

type StreamHandle added in v0.3.0

type StreamHandle uint64

StreamHandle is an opaque handle passed to stop to stop streaming

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL