agent

package
v0.4.0 Latest Latest
Warning

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

 Go to latest Published: Sep 5, 2014 License: MPL-2.0 Imports: 43 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// Do not allow for a interval below this value.
	// Otherwise we risk fork bombing a system.
	MinInterval = time.Second

	// Limit the size of a check's output to the
	// last CheckBufSize. Prevents an enormous buffer
	// from being captured
	CheckBufSize = 4 * 1024 // 4KB
)
View Source 
const (
	MinRPCVersion = 1
	MaxRPCVersion = 1
)
View Source 
const (
	// Limit the size of a watch handlers's output to the
	// last WatchBufSize. Prevents an enormous buffer
	// from being captured
	WatchBufSize = 4 * 1024 // 4KB
)

Variables

This section is empty.

Functions

func ExecScript added in v0.7.0 

func ExecScript(script string) (*exec.Cmd, error)

ExecScript returns a command to execute a script

func FixupCheckType 

func FixupCheckType(raw interface{}) error

func FixupLockDelay 

func FixupLockDelay(raw interface{}) error

FixupLockDelay is used to handle parsing the JSON body to session/create and properly parsing out the lock delay duration value.

func LevelFilter 

func LevelFilter() *logutils.LevelFilter

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

func NewLogWriter 

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 AddressConfig added in v0.7.0 

type AddressConfig struct {
	DNS  string // DNS Query interface
	HTTP string // HTTP API
	RPC  string // CLI RPC
}

AddressConfig is used to provide address overrides for specific services. By default, either ClientAddress or ServerAddress is used.

type Agent 

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

The agent is the long running process that is run on every machine. It exposes an RPC interface that is used by the CLI to control the agent. The agent runs the query interfaces like HTTP, DNS, and RPC. However, it can run in either a client, or server mode. In server mode, it runs a full Consul server. In client-only mode, it only forwards requests to other Consul servers.

func Create 

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

Create is used to create a new Agent. Returns the agent or potentially an error.

func (*Agent) AddCheck 

func (a *Agent) AddCheck(check *structs.HealthCheck, chkType *CheckType) error

AddCheck is used to add a health check to the agent. This entry is persistent and the agent will make a best effort to ensure it is registered. The Check may include a CheckType which is used to automatically update the check status

func (*Agent) AddService 

func (a *Agent) AddService(service *structs.NodeService, chkType *CheckType) error

AddService is used to add a service entry. This entry is persistent and the agent will make a best effort to ensure it is registered

func (*Agent) ForceLeave 

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

ForceLeave is used to remove a failed node from the cluster

func (*Agent) JoinLAN 

func (a *Agent) JoinLAN(addrs []string) (n int, err error)

JoinLAN is used to have the agent join a LAN cluster

func (*Agent) JoinWAN 

func (a *Agent) JoinWAN(addrs []string) (n int, err error)

JoinWAN is used to have the agent join a WAN cluster

func (*Agent) LANMembers 

func (a *Agent) LANMembers() []serf.Member

LANMembers is used to retrieve the LAN members

func (*Agent) LastUserEvent added in v0.7.0 

func (a *Agent) LastUserEvent() *UserEvent

LastUserEvent is used to return the lastest user event. This will return nil if there is no recent event.

func (*Agent) Leave 

func (a *Agent) Leave() error

Leave is used to prepare the agent for a graceful shutdown

func (*Agent) LocalMember 

func (a *Agent) LocalMember() serf.Member

LocalMember is used to return the local node

func (*Agent) PauseSync 

func (a *Agent) PauseSync()

PauseSync is used to pause anti-entropy while bulk changes are make

func (*Agent) RPC 

func (a *Agent) RPC(method string, args interface{}, reply interface{}) error

RPC is used to make an RPC call to the Consul servers This allows the agent to implement the Consul.Interface

func (*Agent) RemoveCheck 

func (a *Agent) RemoveCheck(checkID string) error

RemoveCheck is used to remove a health check. The agent will make a best effort to ensure it is deregistered

func (*Agent) RemoveService 

func (a *Agent) RemoveService(serviceID string) error

RemoveService is used to remove a service entry. The agent will make a best effort to ensure it is deregistered

func (*Agent) ResumeSync 

func (a *Agent) ResumeSync()

ResumeSync is used to unpause anti-entropy after bulk changes are make

func (*Agent) Shutdown 

func (a *Agent) Shutdown() error

Shutdown is used to hard stop the agent. Should be preceeded by a call to Leave to do it gracefully.

func (*Agent) ShutdownCh 

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

ShutdownCh is used to return a channel that can be selected to wait for the agent to perform a shutdown.

func (*Agent) StartSync 

func (a *Agent) StartSync()

StartSync is called once Services and Checks are registered. This is called to prevent a race between clients and the anti-entropy routines

func (*Agent) Stats 

func (a *Agent) Stats() map[string]map[string]string

Stats is used to get various debugging state from the sub-systems

func (*Agent) UpdateCheck 

func (a *Agent) UpdateCheck(checkID, status, output string) error

UpdateCheck is used to update the status of a check. This can only be used with checks of the TTL type.

func (*Agent) UserEvent added in v0.7.0 

func (a *Agent) UserEvent(dc string, params *UserEvent) error

UserEvent is used to fire an event via the Serf layer on the LAN

func (*Agent) UserEvents added in v0.7.0 

func (a *Agent) UserEvents() []*UserEvent

UserEvents is used to return a slice of the most recent user events.

func (*Agent) WANMembers 

func (a *Agent) WANMembers() []serf.Member

WANMembers is used to retrieve the WAN members

type AgentRPC 

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

func NewAgentRPC 

func NewAgentRPC(agent *Agent, listener net.Listener,
	logOutput io.Writer, logWriter *logWriter) *AgentRPC

NewAgentRPC is used to create a new Agent RPC handler

func (*AgentRPC) ReloadCh 

func (i *AgentRPC) ReloadCh() <-chan struct{}

ReloadCh returns a channel that can be watched for when a reload is being triggered.

func (*AgentRPC) Shutdown 

func (i *AgentRPC) Shutdown()

Shutdown is used to shutdown the RPC layer

type AgentSelf 

type AgentSelf struct {
	Config *Config
	Member serf.Member
}

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 CheckDefinition 

type CheckDefinition struct {
	ID        string
	Name      string
	Notes     string
	CheckType `mapstructure:",squash"`
}

ChecKDefinition is used to JSON decode the Check definitions

func DecodeCheckDefinition 

func DecodeCheckDefinition(raw interface{}) (*CheckDefinition, error)

DecodeCheckDefinition is used to decode a check definition

func (*CheckDefinition) HealthCheck 

func (c *CheckDefinition) HealthCheck(node string) *structs.HealthCheck

type CheckMonitor 

type CheckMonitor struct {
	Notify   CheckNotifier
	CheckID  string
	Script   string
	Interval time.Duration
	Logger   *log.Logger
	// contains filtered or unexported fields
}

CheckMonitor is used to periodically invoke a script to determine the health of a given check. It is compatible with nagios plugins and expects the output in the same format.

func (*CheckMonitor) Start 

func (c *CheckMonitor) Start()

Start is used to start a check monitor. Monitor runs until stop is called

func (*CheckMonitor) Stop 

func (c *CheckMonitor) Stop()

Stop is used to stop a check monitor.

type CheckNotifier 

type CheckNotifier interface {
	UpdateCheck(checkID, status, output string)
}

CheckNotifier interface is used by the CheckMonitor to notify when a check has a status update. The update should take care to be idempotent.

type CheckTTL 

type CheckTTL struct {
	Notify  CheckNotifier
	CheckID string
	TTL     time.Duration
	Logger  *log.Logger
	// contains filtered or unexported fields
}

CheckTTL is used to apply a TTL to check status, and enables clients to set the status of a check but upon the TTL expiring, the check status is automatically set to critical.

func (*CheckTTL) SetStatus 

func (c *CheckTTL) SetStatus(status, output string)

SetStatus is used to update the status of the check, and to renew the TTL. If expired, TTL is restarted.

func (*CheckTTL) Start 

func (c *CheckTTL) Start()

Start is used to start a check ttl, runs until Stop()

func (*CheckTTL) Stop 

func (c *CheckTTL) Stop()

Stop is used to stop a check ttl.

type CheckType 

type CheckType struct {
	Script   string
	Interval time.Duration

	TTL time.Duration
}

CheckType is used to create either the CheckMonitor or the CheckTTL. Only one of TTL or Script/Interval needs to be provided

func (*CheckType) IsMonitor 

func (c *CheckType) IsMonitor() bool

IsMonitor checks if this is a Monitor type

func (*CheckType) IsTTL 

func (c *CheckType) IsTTL() bool

IsTTL checks if this is a TTL type

func (*CheckType) Valid 

func (c *CheckType) Valid() bool

Valid checks if the CheckType is valid

type Command 

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

Command is a Command implementation that runs a Consul 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 {
	// Bootstrap is used to bring up the first Consul server, and
	// permits that node to elect itself leader
	Bootstrap bool `mapstructure:"bootstrap"`

	// BootstrapExpect tries to automatically bootstrap the Consul cluster,
	// by witholding peers until enough servers join.
	BootstrapExpect int `mapstructure:"bootstrap_expect"`

	// Server controls if this agent acts like a Consul server,
	// or merely as a client. Servers have more state, take part
	// in leader election, etc.
	Server bool `mapstructure:"server"`

	// Datacenter is the datacenter this node is in. Defaults to dc1
	Datacenter string `mapstructure:"datacenter"`

	// DataDir is the directory to store our state in
	DataDir string `mapstructure:"data_dir"`

	// DNSRecursor can be set to allow the DNS server to recursively
	// resolve non-consul domains
	DNSRecursor string `mapstructure:"recursor"`

	// DNS configuration
	DNSConfig DNSConfig `mapstructure:"dns_config"`

	// Domain is the DNS domain for the records. Defaults to "consul."
	Domain string `mapstructure:"domain"`

	// Encryption key to use for the Serf communication
	EncryptKey string `mapstructure:"encrypt" json:"-"`

	// LogLevel is the level of the logs to putout
	LogLevel string `mapstructure:"log_level"`

	// Node name is the name we use to advertise. Defaults to hostname.
	NodeName string `mapstructure:"node_name"`

	// ClientAddr is used to control the address we bind to for
	// client services (DNS, HTTP, RPC)
	ClientAddr string `mapstructure:"client_addr"`

	// BindAddr is used to control the address we bind to.
	// If not specified, the first private IP we find is used.
	// This controls the address we use for cluster facing
	// services (Gossip, Server RPC)
	BindAddr string `mapstructure:"bind_addr"`

	// AdvertiseAddr is the address we use for advertising our Serf,
	// and Consul RPC IP. If not specified, bind address is used.
	AdvertiseAddr string `mapstructure:"advertise_addr"`

	// Port configurations
	Ports PortConfig

	// Address configurations
	Addresses AddressConfig

	// 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"`

	// SkipLeaveOnInt controls if Serf skips a graceful leave when receiving
	// the INT signal. Defaults false. This can be changed on reload.
	SkipLeaveOnInt bool `mapstructure:"skip_leave_on_interrupt"`

	// StatsiteAddr is the address of a statsite instance. If provided,
	// metrics will be streamed to that instance.
	StatsiteAddr string `mapstructure:"statsite_addr"`

	// StatsdAddr is the address of a statsd instance. If provided,
	// metrics will be sent to that instance.
	StatsdAddr string `mapstructure:"statsd_addr"`

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

	// EnableDebug is used to enable various debugging features
	EnableDebug bool `mapstructure:"enable_debug"`

	// VerifyIncoming is used to verify the authenticity of incoming connections.
	// This means that TCP requests are forbidden, only allowing for TLS. TLS connections
	// must match a provided certificate authority. This can be used to force client auth.
	VerifyIncoming bool `mapstructure:"verify_incoming"`

	// VerifyOutgoing is used to verify the authenticity of outgoing connections.
	// This means that TLS requests are used. TLS connections must match a provided
	// certificate authority. This is used to verify authenticity of server nodes.
	VerifyOutgoing bool `mapstructure:"verify_outgoing"`

	// CAFile is a path to a certificate authority file. This is used with VerifyIncoming
	// or VerifyOutgoing to verify the TLS connection.
	CAFile string `mapstructure:"ca_file"`

	// CertFile is used to provide a TLS certificate that is used for serving TLS connections.
	// Must be provided to serve TLS connections.
	CertFile string `mapstructure:"cert_file"`

	// KeyFile is used to provide a TLS key that is used for serving TLS connections.
	// Must be provided to serve TLS connections.
	KeyFile string `mapstructure:"key_file"`

	// ServerName is used with the TLS certificates to ensure the name we
	// provid ematches the certificate
	ServerName string `mapstructure:"server_name"`

	// 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"`

	// UiDir is the directory containing the Web UI resources.
	// If provided, the UI endpoints will be enabled.
	UiDir string `mapstructure:"ui_dir"`

	// PidFile is the file to store our PID in
	PidFile string `mapstructure:"pid_file"`

	// EnableSyslog is used to also tee all the logs over to syslog. Only supported
	// on linux and OSX. Other platforms will generate an error.
	EnableSyslog bool `mapstructure:"enable_syslog"`

	// SyslogFacility is used to control where the syslog messages go
	// By default, goes to LOCAL0
	SyslogFacility string `mapstructure:"syslog_facility"`

	// RejoinAfterLeave controls our interaction with the cluster after leave.
	// When set to false (default), a leave causes Consul to not rejoin
	// the cluster until an explicit join is received. If this is set to
	// true, we ignore the leave, and rejoin the cluster on start.
	RejoinAfterLeave bool `mapstructure:"rejoin_after_leave"`

	// CheckUpdateInterval controls the interval on which the output of a health check
	// is updated if there is no change to the state. For example, a check in a steady
	// state may run every 5 second generating a unique output (timestamp, etc), forcing
	// constant writes. This allows Consul to defer the write for some period of time,
	// reducing the write pressure when the state is steady.
	CheckUpdateInterval    time.Duration `mapstructure:"-"`
	CheckUpdateIntervalRaw string        `mapstructure:"check_update_interval" json:"-"`

	// ACLToken is the default token used to make requests if a per-request
	// token is not provided. If not configured the 'anonymous' token is used.
	ACLToken string `mapstructure:"acl_token" json:"-"`

	// ACLMasterToken is used to bootstrap the ACL system. It should be specified
	// on the servers in the ACLDatacenter. When the leader comes online, it ensures
	// that the Master token is available. This provides the initial token.
	ACLMasterToken string `mapstructure:"acl_master_token" json:"-"`

	// ACLDatacenter is the central datacenter that holds authoritative
	// ACL records. This must be the same for the entire cluster.
	// If this is not set, ACLs are not enabled. Off by default.
	ACLDatacenter string `mapstructure:"acl_datacenter"`

	// ACLTTL is used to control the time-to-live of cached ACLs . This has
	// a major impact on performance. By default, it is set to 30 seconds.
	ACLTTL    time.Duration `mapstructure:"-"`
	ACLTTLRaw string        `mapstructure:"acl_ttl"`

	// ACLDefaultPolicy is used to control the ACL interaction when
	// there is no defined policy. This can be "allow" which means
	// ACLs are used to black-list, or "deny" which means ACLs are
	// white-lists.
	ACLDefaultPolicy string `mapstructure:"acl_default_policy"`

	// ACLDownPolicy is used to control the ACL interaction when we cannot
	// reach the ACLDatacenter and the token is not in the cache.
	// There are two modes:
	//   * deny - Deny all requests
	//   * extend-cache - Ignore the cache expiration, and allow cached
	//                    ACL's to be used to service requests. This
	//	                  is the default. If the ACL is not in the cache,
	//                    this acts like deny.
	ACLDownPolicy string `mapstructure:"acl_down_policy"`

	// Watches are used to monitor various endpoints and to invoke a
	// handler to act appropriately. These are managed entirely in the
	// agent layer using the standard APIs.
	Watches []map[string]interface{} `mapstructure:"watches"`

	// DisableRemoteExec is used to turn off the remote execution
	// feature. This is for security to prevent unknown scripts from running.
	DisableRemoteExec bool `mapstructure:"disable_remote_exec"`

	// DisableUpdateCheck is used to turn off the automatic update and
	// security bulletin checking.
	DisableUpdateCheck bool `mapstructure:"disable_update_check"`

	// DisableAnonymousSignature is used to turn off the anonymous signature
	// send with the update check. This is used to deduplicate messages.
	DisableAnonymousSignature bool `mapstructure:"disable_anonymous_signature"`

	// AEInterval controls the anti-entropy interval. This is how often
	// the agent attempts to reconcile it's local state with the server'
	// representation of our state. Defaults to every 60s.
	AEInterval time.Duration `mapstructure:"-" json:"-"`

	// Checks holds the provided check definitions
	Checks []*CheckDefinition `mapstructure:"-" json:"-"`

	// Services holds the provided service definitions
	Services []*ServiceDefinition `mapstructure:"-" json:"-"`

	// ConsulConfig can either be provided or a default one created
	ConsulConfig *consul.Config `mapstructure:"-" json:"-"`

	// Revision is the GitCommit this maps to
	Revision string `mapstructure:"-"`

	// Version is the release version number
	Version string `mapstructure:"-"`

	// VersionPrerelease is a label for pre-release builds
	VersionPrerelease string `mapstructure:"-"`

	// WatchPlans contains the compiled watches
	WatchPlans []*watch.WatchPlan `mapstructure:"-" json:"-"`
}

Config is the configuration that can be set for an Agent. Some of this is configurable as CLI flags, but most must be set using a configuration file.

func DecodeConfig 

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 DefaultConfig 

func DefaultConfig() *Config

DefaultConfig is used to return a sane default configuration

func MergeConfig 

func MergeConfig(a, b *Config) *Config

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

func ReadConfigPaths 

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) ClientListener 

func (c *Config) ClientListener(override string, port int) (*net.TCPAddr, error)

ClientListener is used to format a listener for a port on a ClientAddr

func (*Config) ClientListenerAddr 

func (c *Config) ClientListenerAddr(override string, port int) (string, error)

ClientListenerAddr is used to format an address for a port on a ClientAddr, handling the zero IP.

func (*Config) EncryptBytes 

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

EncryptBytes returns the encryption key configured.

type DNSConfig 

type DNSConfig struct {
	// NodeTTL provides the TTL value for a node query
	NodeTTL    time.Duration `mapstructure:"-"`
	NodeTTLRaw string        `mapstructure:"node_ttl" json:"-"`

	// ServiceTTL provides the TTL value for a service
	// query for given service. The "*" wildcard can be used
	// to set a default for all services.
	ServiceTTL    map[string]time.Duration `mapstructure:"-"`
	ServiceTTLRaw map[string]string        `mapstructure:"service_ttl" json:"-"`

	// AllowStale is used to enable lookups with stale
	// data. This gives horizontal read scalability since
	// any Consul server can service the query instead of
	// only the leader.
	AllowStale bool `mapstructure:"allow_stale"`

	// MaxStale is used to bound how stale of a result is
	// accepted for a DNS lookup. This can be used with
	// AllowStale to limit how old of a value is served up.
	// If the stale result exceeds this, another non-stale
	// stale read is performed.
	MaxStale    time.Duration `mapstructure:"-"`
	MaxStaleRaw string        `mapstructure:"max_stale" json:"-"`
}

DNSConfig is used to fine tune the DNS sub-system. It can be used to control cache values, and stale reads

type DNSServer 

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

DNSServer is used to wrap an Agent and expose various service discovery endpoints using a DNS interface.

func NewDNSServer 

func NewDNSServer(agent *Agent, config *DNSConfig, logOutput io.Writer, domain, bind, recursor string) (*DNSServer, error)

NewDNSServer starts a new DNS server to provide an agent interface

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 HTTPServer 

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

HTTPServer is used to wrap an Agent and expose various API's in a RESTful manner

func NewHTTPServer 

func NewHTTPServer(agent *Agent, uiDir string, enableDebug bool, logOutput io.Writer, bind string) (*HTTPServer, error)

NewHTTPServer starts a new HTTP server to provide an interface to the agent.

func (*HTTPServer) ACLClone added in v0.7.0 

func (s *HTTPServer) ACLClone(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) ACLCreate added in v0.7.0 

func (s *HTTPServer) ACLCreate(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) ACLDestroy added in v0.7.0 

func (s *HTTPServer) ACLDestroy(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) ACLGet added in v0.7.0 

func (s *HTTPServer) ACLGet(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) ACLList added in v0.7.0 

func (s *HTTPServer) ACLList(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) ACLUpdate added in v0.7.0 

func (s *HTTPServer) ACLUpdate(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentCheckFail 

func (s *HTTPServer) AgentCheckFail(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentCheckPass 

func (s *HTTPServer) AgentCheckPass(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentCheckWarn 

func (s *HTTPServer) AgentCheckWarn(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentChecks 

func (s *HTTPServer) AgentChecks(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentDeregisterCheck 

func (s *HTTPServer) AgentDeregisterCheck(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentDeregisterService 

func (s *HTTPServer) AgentDeregisterService(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentForceLeave 

func (s *HTTPServer) AgentForceLeave(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentJoin 

func (s *HTTPServer) AgentJoin(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentMembers 

func (s *HTTPServer) AgentMembers(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentRegisterCheck 

func (s *HTTPServer) AgentRegisterCheck(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentRegisterService 

func (s *HTTPServer) AgentRegisterService(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentSelf 

func (s *HTTPServer) AgentSelf(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) AgentServices 

func (s *HTTPServer) AgentServices(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) CatalogDatacenters 

func (s *HTTPServer) CatalogDatacenters(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) CatalogDeregister 

func (s *HTTPServer) CatalogDeregister(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) CatalogNodeServices 

func (s *HTTPServer) CatalogNodeServices(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) CatalogNodes 

func (s *HTTPServer) CatalogNodes(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) CatalogRegister 

func (s *HTTPServer) CatalogRegister(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) CatalogServiceNodes 

func (s *HTTPServer) CatalogServiceNodes(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) CatalogServices 

func (s *HTTPServer) CatalogServices(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) EventFire added in v0.7.0 

func (s *HTTPServer) EventFire(resp http.ResponseWriter, req *http.Request) (interface{}, error)

EventFire is used to fire a new event

func (*HTTPServer) EventList added in v0.7.0 

func (s *HTTPServer) EventList(resp http.ResponseWriter, req *http.Request) (interface{}, error)

EventList is used to retrieve the recent list of events

func (*HTTPServer) HealthChecksInState 

func (s *HTTPServer) HealthChecksInState(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) HealthNodeChecks 

func (s *HTTPServer) HealthNodeChecks(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) HealthServiceChecks 

func (s *HTTPServer) HealthServiceChecks(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) HealthServiceNodes 

func (s *HTTPServer) HealthServiceNodes(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) Index 

func (s *HTTPServer) Index(resp http.ResponseWriter, req *http.Request)

Renders a simple index page

func (*HTTPServer) KVSDelete 

func (s *HTTPServer) KVSDelete(resp http.ResponseWriter, req *http.Request, args *structs.KeyRequest) (interface{}, error)

KVSPut handles a DELETE request

func (*HTTPServer) KVSEndpoint 

func (s *HTTPServer) KVSEndpoint(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) KVSGet 

func (s *HTTPServer) KVSGet(resp http.ResponseWriter, req *http.Request, args *structs.KeyRequest) (interface{}, error)

KVSGet handles a GET request

func (*HTTPServer) KVSGetKeys 

func (s *HTTPServer) KVSGetKeys(resp http.ResponseWriter, req *http.Request, args *structs.KeyRequest) (interface{}, error)

KVSGetKeys handles a GET request for keys

func (*HTTPServer) KVSPut 

func (s *HTTPServer) KVSPut(resp http.ResponseWriter, req *http.Request, args *structs.KeyRequest) (interface{}, error)

KVSPut handles a PUT request

func (*HTTPServer) SessionCreate 

func (s *HTTPServer) SessionCreate(resp http.ResponseWriter, req *http.Request) (interface{}, error)

SessionCreate is used to create a new session

func (*HTTPServer) SessionDestroy 

func (s *HTTPServer) SessionDestroy(resp http.ResponseWriter, req *http.Request) (interface{}, error)

SessionDestroy is used to destroy an existing session

func (*HTTPServer) SessionGet 

func (s *HTTPServer) SessionGet(resp http.ResponseWriter, req *http.Request) (interface{}, error)

SessionGet is used to get info for a particular session

func (*HTTPServer) SessionList 

func (s *HTTPServer) SessionList(resp http.ResponseWriter, req *http.Request) (interface{}, error)

SessionList is used to list all the sessions

func (*HTTPServer) SessionsForNode 

func (s *HTTPServer) SessionsForNode(resp http.ResponseWriter, req *http.Request) (interface{}, error)

SessionsForNode returns all the nodes belonging to a node

func (*HTTPServer) Shutdown 

func (s *HTTPServer) Shutdown()

Shutdown is used to shutdown the HTTP server

func (*HTTPServer) StatusLeader 

func (s *HTTPServer) StatusLeader(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) StatusPeers 

func (s *HTTPServer) StatusPeers(resp http.ResponseWriter, req *http.Request) (interface{}, error)

func (*HTTPServer) UINodeInfo 

func (s *HTTPServer) UINodeInfo(resp http.ResponseWriter, req *http.Request) (interface{}, error)

UINodeInfo is used to get info on a single node in a given datacenter. We return a NodeInfo which provides overview information for the node

func (*HTTPServer) UINodes 

func (s *HTTPServer) UINodes(resp http.ResponseWriter, req *http.Request) (interface{}, error)

UINodes is used to list the nodes in a given datacenter. We return a NodeDump which provides overview information for all the nodes

func (*HTTPServer) UIServices 

func (s *HTTPServer) UIServices(resp http.ResponseWriter, req *http.Request) (interface{}, error)

UIServices is used to list the services in a given datacenter. We return a ServiceSummary which provides overview information for the service

type LogHandler 

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 

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

type PortConfig 

type PortConfig struct {
	DNS     int // DNS Query interface
	HTTP    int // HTTP API
	RPC     int // CLI RPC
	SerfLan int `mapstructure:"serf_lan"` // LAN gossip (Client + Server)
	SerfWan int `mapstructure:"serf_wan"` // WAN gossip (Server onlyg)
	Server  int // Server internal RPC
}

Ports is used to simplify the configuration by providing default ports, and allowing the addresses to only be specified once

type RPCClient 

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

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

func NewRPCClient 

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 

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, wan bool) (int, error)

Join is used to instruct the agent to attempt a join

func (*RPCClient) LANMembers 

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

LANMembers is used to fetch a list of known members

func (*RPCClient) Leave 

func (c *RPCClient) Leave() error

Leave is used to trigger a graceful leave and shutdown

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) Reload 

func (c *RPCClient) Reload() error

Reload is used to trigger a configuration reload

func (*RPCClient) Stats 

func (c *RPCClient) Stats() (map[string]map[string]string, error)

Stats is used to get debugging state information

func (*RPCClient) Stop 

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

Stop is used to unsubscribe from logs or event streams

func (*RPCClient) WANMembers 

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

WANMembers is used to fetch a list of known members

type ServiceDefinition 

type ServiceDefinition struct {
	ID    string
	Name  string
	Tags  []string
	Port  int
	Check CheckType
}

ServiceDefinition is used to JSON decode the Service definitions

func DecodeServiceDefinition 

func DecodeServiceDefinition(raw interface{}) (*ServiceDefinition, error)

DecodeServiceDefinition is used to decode a service definition

func (*ServiceDefinition) CheckType 

func (s *ServiceDefinition) CheckType() *CheckType

func (*ServiceDefinition) NodeService 

func (s *ServiceDefinition) NodeService() *structs.NodeService

type ServiceSummary 

type ServiceSummary struct {
	Name           string
	Nodes          []string
	ChecksPassing  int
	ChecksWarning  int
	ChecksCritical int
}

ServiceSummary is used to summarize a service

type StreamHandle 

type StreamHandle uint64

StreamHandle is an opaque handle passed to stop to stop streaming

type SyslogWrapper 

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

SyslogWrapper is used to cleaup log messages before writing them to a Syslogger. Implements the io.Writer interface.

func (*SyslogWrapper) Write 

func (s *SyslogWrapper) Write(p []byte) (int, error)

Write is used to implement io.Writer

type UserEvent added in v0.7.0 

type UserEvent struct {
	// ID of the user event. Automatically generated.
	ID string

	// Name of the event
	Name string `codec:"n"`

	// Optional payload
	Payload []byte `codec:"p,omitempty"`

	// NodeFilter is a regular expression to filter on nodes
	NodeFilter string `codec:"nf,omitempty"`

	// ServiceFilter is a regular expression to filter on services
	ServiceFilter string `codec:"sf,omitempty"`

	// TagFilter is a regular expression to filter on tags of a service,
	// must be provided with ServiceFilter
	TagFilter string `codec:"tf,omitempty"`

	// Version of the user event. Automatically generated.
	Version int `codec:"v"`

	// LTime is the lamport time. Automatically generated.
	LTime uint64 `codec:"-"`
}

UserEventParam is used to parameterize a user event

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.