ActiveGo 1.8Package agent
Overview ▹
Index ▹
Constants
const (
// MinInterval is the minimal interval between
// two checks. Do not allow for a interval below this value.
// Otherwise we risk fork bombing a system.
MinInterval = time.Second
// CheckBufSize is the maximum size of the captured
// check output. Prevents an enormous buffer
// from being captured
CheckBufSize = 4 * 1024 // 4KB
// UserAgent is the value of the User-Agent header
// for HTTP health checks.
UserAgent = "Consul Health Check"
)
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
TempDir defines the base dir for temporary directories.
var TempDir = os.TempDir()
func ACLDisabled ¶
func ACLDisabled(resp http.ResponseWriter, req *http.Request) (interface{}, error)
ACLDisabled handles if ACL datacenter is not configured
func Asset ¶
func Asset(name string) ([]byte, error)
Asset loads and returns the asset for the given name. It returns an error if the asset could not be found or could not be loaded.
func AssetDir ¶
func AssetDir(name string) ([]string, error)
AssetDir returns the file names below a certain directory embedded in the file by go-bindata. For example if you run go-bindata on data/... and data contains the following hierarchy:
data/
foo.txt
img/
a.png
b.png
then AssetDir("data") would return []string{"foo.txt", "img"} AssetDir("data/img") would return []string{"a.png", "b.png"} AssetDir("foo.txt") and AssetDir("notexist") would return an error AssetDir("") will return []string{"data"}.
func AssetInfo ¶
func AssetInfo(name string) (os.FileInfo, error)
AssetInfo loads and returns the asset info for the given name. It returns an error if the asset could not be found or could not be loaded.
func AssetNames ¶
func AssetNames() []string
AssetNames returns the names of the assets.
func Bool ¶
func Bool(b bool) *bool
Bool is used to initialize bool pointers in struct literals.
func Duration ¶
func Duration(d time.Duration) *time.Duration
Duration is used to initialize time.Duration pointers in struct literals.
func ExecScript ¶
func ExecScript(script string) (*exec.Cmd, error)
ExecScript returns a command to execute a script
func FixupCheckType ¶
func FixupCheckType(raw interface{}) error
func FixupConfigDurations ¶
func FixupConfigDurations(raw interface{}) error
FixupConfigDurations is used to handle parsing the duration fields in the Autopilot config struct
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 MustAsset ¶
func MustAsset(name string) []byte
MustAsset is like Asset but panics when Asset would return an error. It simplifies safe initialization of global variables.
func ParseMetaPair ¶
func ParseMetaPair(raw string) (string, string)
ParseMetaPair parses a key/value pair of the form key:value
func ParseRelayFactor ¶
func ParseRelayFactor(n int) (uint8, error)
ParseRelayFactor validates and converts the given relay factor to uint8
func RestoreAsset ¶
func RestoreAsset(dir, name string) error
RestoreAsset restores an asset under the given directory
func RestoreAssets ¶
func RestoreAssets(dir, name string) error
RestoreAssets restores an asset under the given directory recursively
func TenPorts ¶
func TenPorts() int
TenPorts returns the first port number of a block of ten random ports.
func Uint64 ¶
func Uint64(i uint64) *uint64
Uint64 is used to initialize uint64 pointers in struct literals.
func UniqueID ¶
func UniqueID() string
type AddressConfig ¶
AddressConfig is used to provide address overrides for specific services. By default, either ClientAddress or ServerAddress is used.
type AddressConfig struct {
DNS string // DNS Query interface
HTTP string // HTTP API
HTTPS string // HTTPS API
// RPC is deprecated and is no longer used. It will be removed in a future
// version.
RPC string // CLI RPC
}
type AdvertiseAddrsConfig ¶
type AdvertiseAddrsConfig struct {
SerfLan *net.TCPAddr `mapstructure:"-"`
SerfLanRaw string `mapstructure:"serf_lan"`
SerfWan *net.TCPAddr `mapstructure:"-"`
SerfWanRaw string `mapstructure:"serf_wan"`
RPC *net.TCPAddr `mapstructure:"-"`
RPCRaw string `mapstructure:"rpc"`
}
type Agent ¶
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.
type Agent struct {
// Output sink for logs
LogOutput io.Writer
// Used for streaming logs to
LogWriter *logger.LogWriter
// contains filtered or unexported fields
}
func NewAgent ¶
func NewAgent(c *Config) (*Agent, error)
func (*Agent) AddCheck ¶
func (a *Agent) AddCheck(check *structs.HealthCheck, chkType *CheckType, persist bool, token string) 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, chkTypes CheckTypes, persist bool, token string) 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) DisableNodeMaintenance ¶
func (a *Agent) DisableNodeMaintenance()
DisableNodeMaintenance removes a node from maintenance mode
func (*Agent) DisableServiceMaintenance ¶
func (a *Agent) DisableServiceMaintenance(serviceID string) error
DisableServiceMaintenance will deregister the fake maintenance mode check if the service has been marked as in maintenance.
func (*Agent) EnableNodeMaintenance ¶
func (a *Agent) EnableNodeMaintenance(reason, token string)
EnableNodeMaintenance places a node into maintenance mode.
func (*Agent) EnableServiceMaintenance ¶
func (a *Agent) EnableServiceMaintenance(serviceID, reason, token string) error
EnableServiceMaintenance will register a false health check against the given service ID with critical status. This will exclude the service from queries.
func (*Agent) ForceLeave ¶
func (a *Agent) ForceLeave(node string) (err error)
ForceLeave is used to remove a failed node from the cluster
func (*Agent) GetLANCoordinate ¶
func (a *Agent) GetLANCoordinate() (*coordinate.Coordinate, error)
GetLANCoordinate returns the coordinate of this node in the local pool (assumes coordinates are enabled, so check that before calling).
func (*Agent) GossipEncrypted ¶
func (a *Agent) GossipEncrypted() bool
func (*Agent) InjectEndpoint ¶
func (a *Agent) InjectEndpoint(endpoint string, handler interface{}) error
InjectEndpoint overrides the given endpoint with a substitute one. Note that not all agent methods use this mechanism, and that is should only be used for testing.
func (*Agent) InstallKey ¶
func (a *Agent) InstallKey(key, token string, relayFactor uint8) (*structs.KeyringResponses, error)
InstallKey installs a new gossip encryption key
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 ¶
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) ListKeys ¶
func (a *Agent) ListKeys(token string, relayFactor uint8) (*structs.KeyringResponses, error)
ListKeys lists out all keys installed on the collective Consul cluster. This includes both servers and clients in all DC's.
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) ReloadCh ¶
func (a *Agent) ReloadCh() chan chan error
ReloadCh is used to return a channel that can be used for triggering reloads and returning a response.
func (*Agent) ReloadConfig ¶
func (a *Agent) ReloadConfig(newCfg *Config) (bool, error)
func (*Agent) RemoveCheck ¶
func (a *Agent) RemoveCheck(checkID types.CheckID, persist bool) error
RemoveCheck is used to remove a health check. The agent will make a best effort to ensure it is deregistered
func (*Agent) RemoveKey ¶
func (a *Agent) RemoveKey(key, token string, relayFactor uint8) (*structs.KeyringResponses, error)
RemoveKey will remove a gossip encryption key from the keyring
func (*Agent) RemoveService ¶
func (a *Agent) RemoveService(serviceID string, persist bool) 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) RetryJoinCh ¶
func (a *Agent) RetryJoinCh() <-chan error
RetryJoinCh is a channel that transports errors from the retry join process.
func (*Agent) Shutdown ¶
func (a *Agent) Shutdown() error
Shutdown is used to hard stop the agent. Should be preceded 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) SnapshotRPC ¶
func (a *Agent) SnapshotRPC(args *structs.SnapshotRequest, in io.Reader, out io.Writer,
replyFn consul.SnapshotReplyFn) error
SnapshotRPC performs the requested snapshot RPC against the Consul server in a streaming manner. The contents of in will be read and passed along as the payload, and the response message will determine the error status, and any return payload will be written to out.
func (*Agent) Start ¶
func (a *Agent) Start() error
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) UseKey ¶
func (a *Agent) UseKey(key, token string, relayFactor uint8) (*structs.KeyringResponses, error)
UseKey changes the primary encryption key used to encrypt messages
func (*Agent) UserEvent ¶
func (a *Agent) UserEvent(dc, token string, params *UserEvent) error
UserEvent is used to fire an event via the Serf layer on the LAN
func (*Agent) UserEvents ¶
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 AppendSliceValue ¶
AppendSliceValue implements the flag.Value interface and allows multiple calls to the same variable to append a list.
type AppendSliceValue []string
func (*AppendSliceValue) Set ¶
func (s *AppendSliceValue) Set(value string) error
func (*AppendSliceValue) String ¶
func (s *AppendSliceValue) String() string
type Autopilot ¶
Autopilot is used to configure helpful features for operating Consul servers.
type Autopilot struct {
// CleanupDeadServers enables the automatic cleanup of dead servers when new ones
// are added to the peer list. Defaults to true.
CleanupDeadServers *bool `mapstructure:"cleanup_dead_servers"`
// LastContactThreshold is the limit on the amount of time a server can go
// without leader contact before being considered unhealthy.
LastContactThreshold *time.Duration `mapstructure:"-" json:"-"`
LastContactThresholdRaw string `mapstructure:"last_contact_threshold"`
// MaxTrailingLogs is the amount of entries in the Raft Log that a server can
// be behind before being considered unhealthy.
MaxTrailingLogs *uint64 `mapstructure:"max_trailing_logs"`
// ServerStabilizationTime is the minimum amount of time a server must be
// in a stable, healthy state before it can be added to the cluster. Only
// applicable with Raft protocol version 3 or higher.
ServerStabilizationTime *time.Duration `mapstructure:"-" json:"-"`
ServerStabilizationTimeRaw string `mapstructure:"server_stabilization_time"`
// (Enterprise-only) RedundancyZoneTag is the Meta tag to use for separating servers
// into zones for redundancy. If left blank, this feature will be disabled.
RedundancyZoneTag string `mapstructure:"redundancy_zone_tag"`
// (Enterprise-only) DisableUpgradeMigration will disable Autopilot's upgrade migration
// strategy of waiting until enough newer-versioned servers have been added to the
// cluster before promoting them to voters.
DisableUpgradeMigration *bool `mapstructure:"disable_upgrade_migration"`
}
type CheckDefinition ¶
CheckDefinition is used to JSON decode the Check definitions
type CheckDefinition struct {
ID types.CheckID
Name string
Notes string
ServiceID string
Token string
Status string
// Copied fields from CheckType without the fields
// already present in CheckDefinition:
//
// ID (CheckID), Name, Status, Notes
//
Script string
HTTP string
Header map[string][]string
Method string
TCP string
Interval time.Duration
DockerContainerID string
Shell string
TLSSkipVerify bool
Timeout time.Duration
TTL time.Duration
DeregisterCriticalServiceAfter time.Duration
}
func DecodeCheckDefinition ¶
func DecodeCheckDefinition(raw interface{}) (*CheckDefinition, error)
DecodeCheckDefinition is used to decode a check definition
func (*CheckDefinition) CheckType ¶
func (c *CheckDefinition) CheckType() *CheckType
func (*CheckDefinition) HealthCheck ¶
func (c *CheckDefinition) HealthCheck(node string) *structs.HealthCheck
type CheckDocker ¶
CheckDocker is used to periodically invoke a script to determine the health of an application running inside a Docker Container. We assume that the script is compatible with nagios plugins and expects the output in the same format.
type CheckDocker struct {
Notify CheckNotifier
CheckID types.CheckID
Script string
DockerContainerID string
Shell string
Interval time.Duration
Logger *log.Logger
// contains filtered or unexported fields
}
func (*CheckDocker) Init ¶
func (c *CheckDocker) Init() error
Init initializes the Docker Client
func (*CheckDocker) Start ¶
func (c *CheckDocker) Start()
Start is used to start checks. Docker Checks runs until stop is called
func (*CheckDocker) Stop ¶
func (c *CheckDocker) Stop()
Stop is used to stop a docker check.
type CheckHTTP ¶
CheckHTTP is used to periodically make an HTTP request to determine the health of a given check. The check is passing if the response code is 2XX. The check is warning if the response code is 429. The check is critical if the response code is anything else or if the request returns an error
type CheckHTTP struct {
Notify CheckNotifier
CheckID types.CheckID
HTTP string
Header map[string][]string
Method string
Interval time.Duration
Timeout time.Duration
Logger *log.Logger
TLSSkipVerify bool
// contains filtered or unexported fields
}
func (*CheckHTTP) Start ¶
func (c *CheckHTTP) Start()
Start is used to start an HTTP check. The check runs until stop is called
func (*CheckHTTP) Stop ¶
func (c *CheckHTTP) Stop()
Stop is used to stop an HTTP check.
type CheckMonitor ¶
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.
type CheckMonitor struct {
Notify CheckNotifier
CheckID types.CheckID
Script string
Interval time.Duration
Timeout time.Duration
Logger *log.Logger
// contains filtered or unexported fields
}
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 ¶
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 CheckNotifier interface {
UpdateCheck(checkID types.CheckID, status, output string)
}
type CheckTCP ¶
CheckTCP is used to periodically make an TCP/UDP connection to determine the health of a given check. The check is passing if the connection succeeds The check is critical if the connection returns an error
type CheckTCP struct {
Notify CheckNotifier
CheckID types.CheckID
TCP string
Interval time.Duration
Timeout time.Duration
Logger *log.Logger
// contains filtered or unexported fields
}
func (*CheckTCP) Start ¶
func (c *CheckTCP) Start()
Start is used to start a TCP check. The check runs until stop is called
func (*CheckTCP) Stop ¶
func (c *CheckTCP) Stop()
Stop is used to stop a TCP check.
type CheckTTL ¶
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.
type CheckTTL struct {
Notify CheckNotifier
CheckID types.CheckID
TTL time.Duration
Logger *log.Logger
// contains filtered or unexported fields
}
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 ¶
CheckType is used to create either the CheckMonitor or the CheckTTL. Five types are supported: Script, HTTP, TCP, Docker and TTL. Script, HTTP, Docker and TCP all require Interval. Only one of the types may to be provided: TTL or Script/Interval or HTTP/Interval or TCP/Interval or Docker/Interval.
type CheckType struct {
CheckID types.CheckID
Name string
Status string
Notes string
Script string
HTTP string
Header map[string][]string
Method string
TCP string
Interval time.Duration
DockerContainerID string
Shell string
TLSSkipVerify bool
Timeout time.Duration
TTL time.Duration
// DeregisterCriticalServiceAfter, if >0, will cause the associated
// service, if any, to be deregistered if this check is critical for
// longer than this duration.
DeregisterCriticalServiceAfter time.Duration
}
func (*CheckType) IsDocker ¶
func (c *CheckType) IsDocker() bool
IsDocker returns true when checking a docker container.
func (*CheckType) IsHTTP ¶
func (c *CheckType) IsHTTP() bool
IsHTTP checks if this is a HTTP type
func (*CheckType) IsMonitor ¶
func (c *CheckType) IsMonitor() bool
IsMonitor checks if this is a Monitor type
func (*CheckType) IsTCP ¶
func (c *CheckType) IsTCP() bool
IsTCP checks if this is a TCP 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 CheckTypes ¶
type CheckTypes []*CheckType
type Command ¶
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.
type Command struct {
base.Command
Revision string
Version string
VersionPrerelease string
HumanVersion string
ShutdownCh <-chan struct{}
// contains filtered or unexported fields
}
func (*Command) Help ¶
func (cmd *Command) Help() string
func (*Command) Run ¶
func (cmd *Command) Run(args []string) int
func (*Command) Synopsis ¶
func (cmd *Command) Synopsis() string
type Config ¶
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.
type Config struct {
// DevMode enables a fast-path mode of operation to bring up an in-memory
// server with minimal configuration. Useful for developing Consul.
DevMode bool `mapstructure:"-"`
// Performance is used to tune the performance of Consul's subsystems.
Performance Performance `mapstructure:"performance"`
// 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 withholding 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"`
// (Enterprise-only) NonVotingServer is whether this server will act as a non-voting member
// of the cluster to help provide read scalability.
NonVotingServer bool `mapstructure:"non_voting_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"`
// DNSRecursors can be set to allow the DNS servers to recursively
// resolve non-consul domains. It is deprecated, and merges into the
// recursors array.
DNSRecursor string `mapstructure:"recursor"`
// DNSRecursors can be set to allow the DNS servers to recursively
// resolve non-consul domains
DNSRecursors []string `mapstructure:"recursors"`
// 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:"-"`
// EncryptVerifyIncoming and EncryptVerifyOutgoing are used to enforce
// incoming/outgoing gossip encryption and can be used to upshift to
// encrypted gossip on a running cluster.
EncryptVerifyIncoming *bool `mapstructure:"encrypt_verify_incoming"`
EncryptVerifyOutgoing *bool `mapstructure:"encrypt_verify_outgoing"`
// LogLevel is the level of the logs to putout
LogLevel string `mapstructure:"log_level"`
// Node ID is a unique ID for this node across space and time. Defaults
// to a randomly-generated ID that persists in the data-dir.
NodeID types.NodeID `mapstructure:"node_id"`
// DisableHostNodeID will prevent Consul from using information from the
// host to generate a node ID, and will cause Consul to generate a
// random ID instead.
DisableHostNodeID bool `mapstructure:"disable_host_node_id"`
// 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, HTTPS, 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"`
// SerfWanBindAddr 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) Serf
SerfWanBindAddr string `mapstructure:"serf_wan_bind"`
// SerfLanBindAddr 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) Serf
SerfLanBindAddr string `mapstructure:"serf_lan_bind"`
// 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"`
// AdvertiseAddrs configuration
AdvertiseAddrs AdvertiseAddrsConfig `mapstructure:"advertise_addrs"`
// AdvertiseAddrWan is the address we use for advertising our
// Serf WAN IP. If not specified, the general advertise address is used.
AdvertiseAddrWan string `mapstructure:"advertise_addr_wan"`
// TranslateWanAddrs controls whether or not Consul should prefer
// the "wan" tagged address when doing lookups in remote datacenters.
// See TaggedAddresses below for more details.
TranslateWanAddrs bool `mapstructure:"translate_wan_addrs"`
// Port configurations
Ports PortConfig
// Address configurations
Addresses AddressConfig
// Tagged addresses. These are used to publish a set of addresses for
// for a node, which can be used by the remote agent. We currently
// populate only the "wan" tag based on the SerfWan advertise address,
// but this structure is here for possible future features with other
// user-defined tags. The "wan" tag will be used by remote agents if
// they are configured with TranslateWanAddrs set to true.
TaggedAddresses map[string]string
// Node metadata key/value pairs. These are excluded from JSON output
// because they can be reloaded and might be stale when shown from the
// config instead of the local state.
Meta map[string]string `mapstructure:"node_meta" json:"-"`
// LeaveOnTerm controls if Serf does a graceful leave when receiving
// the TERM signal. Defaults true on clients, false on servers. 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 on clients, true on
// servers. This can be changed on reload.
SkipLeaveOnInt *bool `mapstructure:"skip_leave_on_interrupt"`
// Autopilot is used to configure helpful features for operating Consul servers.
Autopilot Autopilot `mapstructure:"autopilot"`
Telemetry Telemetry `mapstructure:"telemetry"`
// Protocol is the Consul protocol version to use.
Protocol int `mapstructure:"protocol"`
// RaftProtocol sets the Raft protocol version to use on this server.
RaftProtocol int `mapstructure:"raft_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"`
// VerifyIncomingRPC is used to verify the authenticity of incoming RPC 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.
VerifyIncomingRPC bool `mapstructure:"verify_incoming_rpc"`
// VerifyIncomingHTTPS is used to verify the authenticity of incoming HTTPS 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.
VerifyIncomingHTTPS bool `mapstructure:"verify_incoming_https"`
// 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"`
// VerifyServerHostname is used to enable hostname verification of servers. This
// ensures that the certificate presented is valid for server.<datacenter>.<domain>.
// This prevents a compromised client from being restarted as a server, and then
// intercepting request traffic as well as being added as a raft peer. This should be
// enabled by default with VerifyOutgoing, but for legacy reasons we cannot break
// existing clients.
VerifyServerHostname bool `mapstructure:"verify_server_hostname"`
// 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"`
// CAPath is a path to a directory of certificate authority files. This is used with
// VerifyIncoming or VerifyOutgoing to verify the TLS connection.
CAPath string `mapstructure:"ca_path"`
// 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
// provide matches the certificate
ServerName string `mapstructure:"server_name"`
// TLSMinVersion is used to set the minimum TLS version used for TLS connections.
TLSMinVersion string `mapstructure:"tls_min_version"`
// TLSCipherSuites is used to specify the list of supported ciphersuites.
TLSCipherSuites []uint16 `mapstructure:"-" json:"-"`
TLSCipherSuitesRaw string `mapstructure:"tls_cipher_suites"`
// TLSPreferServerCipherSuites specifies whether to prefer the server's ciphersuite
// over the client ciphersuites.
TLSPreferServerCipherSuites bool `mapstructure:"tls_prefer_server_cipher_suites"`
// 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"`
// StartJoinWan is a list of addresses to attempt to join -wan when the
// agent starts. If Serf is unable to communicate with any of these
// addresses, then the agent will error and exit.
StartJoinWan []string `mapstructure:"start_join_wan"`
// RetryJoin is a list of addresses to join with retry enabled.
RetryJoin []string `mapstructure:"retry_join"`
// RetryMaxAttempts specifies the maximum number of times to retry joining a
// host on startup. This is useful for cases where we know the node will be
// online eventually.
RetryMaxAttempts int `mapstructure:"retry_max"`
// RetryInterval specifies the amount of time to wait in between join
// attempts on agent start. The minimum allowed value is 1 second and
// the default is 30s.
RetryInterval time.Duration `mapstructure:"-" json:"-"`
RetryIntervalRaw string `mapstructure:"retry_interval"`
// RetryJoinEC2 specifies the configuration for auto-join on EC2.
RetryJoinEC2 RetryJoinEC2 `mapstructure:"retry_join_ec2"`
// RetryJoinGCE specifies the configuration for auto-join on GCE.
RetryJoinGCE RetryJoinGCE `mapstructure:"retry_join_gce"`
// RetryJoinAzure specifies the configuration for auto-join on Azure.
RetryJoinAzure RetryJoinAzure `mapstructure:"retry_join_azure"`
// RetryJoinWan is a list of addresses to join -wan with retry enabled.
RetryJoinWan []string `mapstructure:"retry_join_wan"`
// RetryMaxAttemptsWan specifies the maximum number of times to retry joining a
// -wan host on startup. This is useful for cases where we know the node will be
// online eventually.
RetryMaxAttemptsWan int `mapstructure:"retry_max_wan"`
// RetryIntervalWan specifies the amount of time to wait in between join
// -wan attempts on agent start. The minimum allowed value is 1 second and
// the default is 30s.
RetryIntervalWan time.Duration `mapstructure:"-" json:"-"`
RetryIntervalWanRaw string `mapstructure:"retry_interval_wan"`
// ReconnectTimeout* specify the amount of time to wait to reconnect with
// another agent before deciding it's permanently gone. This can be used to
// control the time it takes to reap failed nodes from the cluster.
ReconnectTimeoutLan time.Duration `mapstructure:"-"`
ReconnectTimeoutLanRaw string `mapstructure:"reconnect_timeout"`
ReconnectTimeoutWan time.Duration `mapstructure:"-"`
ReconnectTimeoutWanRaw string `mapstructure:"reconnect_timeout_wan"`
// EnableUI enables the statically-compiled assets for the Consul web UI and
// serves them at the default /ui/ endpoint automatically.
EnableUI bool `mapstructure:"ui"`
// 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:"-"`
// CheckReapInterval controls the interval on which we will look for
// failed checks and reap their associated services, if so configured.
CheckReapInterval time.Duration `mapstructure:"-"`
// CheckDeregisterIntervalMin is the smallest allowed interval to set
// a check's DeregisterCriticalServiceAfter value to.
CheckDeregisterIntervalMin time.Duration `mapstructure:"-"`
// 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:"-"`
// ACLAgentMasterToken is a special token that has full read and write
// privileges for this agent, and can be used to call agent endpoints
// when no servers are available.
ACLAgentMasterToken string `mapstructure:"acl_agent_master_token" json:"-"`
// ACLAgentToken is the default token used to make requests for the agent
// itself, such as for registering itself with the catalog. If not
// configured, the 'acl_token' will be used.
ACLAgentToken string `mapstructure:"acl_agent_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"`
// ACLDisabledTTL is used by clients to determine how long they will
// wait to check again with the servers if they discover ACLs are not
// enabled.
ACLDisabledTTL time.Duration `mapstructure:"-"`
// 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:
// * allow - Allow all requests
// * 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"`
// ACLReplicationToken is used to fetch ACLs from the ACLDatacenter in
// order to replicate them locally. Setting this to a non-empty value
// also enables replication. Replication is only available in datacenters
// other than the ACLDatacenter.
ACLReplicationToken string `mapstructure:"acl_replication_token" json:"-"`
// ACLEnforceVersion8 is used to gate a set of ACL policy features that
// are opt-in prior to Consul 0.8 and opt-out in Consul 0.8 and later.
ACLEnforceVersion8 *bool `mapstructure:"acl_enforce_version_8"`
// 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"`
// HTTPAPIResponseHeaders are used to add HTTP header response fields to the HTTP API responses.
HTTPAPIResponseHeaders map[string]string `mapstructure:"http_api_response_headers"`
// AEInterval controls the anti-entropy interval. This is how often
// the agent attempts to reconcile its local state with the server's
// representation of our state. Defaults to every 60s.
AEInterval time.Duration `mapstructure:"-" json:"-"`
// DisableCoordinates controls features related to network coordinates.
DisableCoordinates bool `mapstructure:"disable_coordinates"`
// SyncCoordinateRateTarget controls the rate for sending network
// coordinates to the server, in updates per second. This is the max rate
// that the server supports, so we scale our interval based on the size
// of the cluster to try to achieve this in aggregate at the server.
SyncCoordinateRateTarget float64 `mapstructure:"-" json:"-"`
// SyncCoordinateIntervalMin sets the minimum interval that coordinates
// will be sent to the server. We scale the interval based on the cluster
// size, but below a certain interval it doesn't make sense send them any
// faster.
SyncCoordinateIntervalMin 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.Plan `mapstructure:"-" json:"-"`
// UnixSockets is a map of socket configuration data
UnixSockets UnixSocketConfig `mapstructure:"unix_sockets"`
// Minimum Session TTL
SessionTTLMin time.Duration `mapstructure:"-"`
SessionTTLMinRaw string `mapstructure:"session_ttl_min"`
// deprecated fields
// keep them exported since otherwise the error messages don't show up
DeprecatedAtlasInfrastructure string `mapstructure:"atlas_infrastructure" json:"-"`
DeprecatedAtlasToken string `mapstructure:"atlas_token" json:"-"`
DeprecatedAtlasACLToken string `mapstructure:"atlas_acl_token" json:"-"`
DeprecatedAtlasJoin bool `mapstructure:"atlas_join" json:"-"`
DeprecatedAtlasEndpoint string `mapstructure:"atlas_endpoint" json:"-"`
}
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 DevConfig ¶
func DevConfig() *Config
DevConfig is used to return a set of configuration to use for dev mode.
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 TestACLConfig ¶
func TestACLConfig() *Config
TestACLConfig returns a default configuration for testing an agent with ACLs.
func TestConfig ¶
func TestConfig() *Config
TestConfig returns a unique default configuration for testing an agent.
func (*Config) ClientListener ¶
func (c *Config) ClientListener(override string, port int) (net.Addr, error)
ClientListener is used to format a listener for a port on a ClientAddr
func (*Config) DNSAddrs ¶
func (c *Config) DNSAddrs() ([]ProtoAddr, error)
func (*Config) EncryptBytes ¶
func (c *Config) EncryptBytes() ([]byte, error)
EncryptBytes returns the encryption key configured.
func (*Config) GetTokenForAgent ¶
func (c *Config) GetTokenForAgent() string
GetTokenForAgent returns the token the agent should use for its own internal operations, such as registering itself with the catalog.
func (*Config) HTTPAddrs ¶
func (c *Config) HTTPAddrs() ([]ProtoAddr, error)
HTTPAddrs returns the bind addresses for the HTTP server and the application protocol which should be served, e.g. 'http' or 'https'.
func (*Config) IncomingHTTPSConfig ¶
func (c *Config) IncomingHTTPSConfig() (*tls.Config, error)
IncomingHTTPSConfig returns the TLS configuration for HTTPS connections to consul.
type CriticalCheck ¶
CriticalCheck is used to return the duration a check has been critical along with its associated health check.
type CriticalCheck struct {
CriticalFor time.Duration
Check *structs.HealthCheck
}
type DNSConfig ¶
DNSConfig is used to fine tune the DNS sub-system. It can be used to control cache values, and stale reads
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"`
// EnableTruncate is used to enable setting the truncate
// flag for UDP DNS queries. This allows unmodified
// clients to re-query the consul server using TCP
// when the total number of records exceeds the number
// returned by default for UDP.
EnableTruncate bool `mapstructure:"enable_truncate"`
// UDPAnswerLimit is used to limit the maximum number of DNS Resource
// Records returned in the ANSWER section of a DNS response. This is
// not normally useful and will be limited based on the querying
// protocol, however systems that implemented §6 Rule 9 in RFC3484
// may want to set this to `1` in order to subvert §6 Rule 9 and
// re-obtain the effect of randomized resource records (i.e. each
// answer contains only one IP, but the IP changes every request).
// RFC3484 sorts answers in a deterministic order, which defeats the
// purpose of randomized DNS responses. This RFC has been obsoleted
// by RFC6724 and restores the desired behavior of randomized
// responses, however a large number of Linux hosts using glibc(3)
// implemented §6 Rule 9 and may need this option (e.g. CentOS 5-6,
// Debian Squeeze, etc).
UDPAnswerLimit int `mapstructure:"udp_answer_limit"`
// 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:"-"`
// OnlyPassing is used to determine whether to filter nodes
// whose health checks are in any non-passing state. By
// default, only nodes in a critical state are excluded.
OnlyPassing bool `mapstructure:"only_passing"`
// DisableCompression is used to control whether DNS responses are
// compressed. In Consul 0.7 this was turned on by default and this
// config was added as an opt-out.
DisableCompression bool `mapstructure:"disable_compression"`
// RecursorTimeout specifies the timeout in seconds
// for Consul's internal dns client used for recursion.
// This value is used for the connection, read and write timeout.
// Default: 2s
RecursorTimeout time.Duration `mapstructure:"-"`
RecursorTimeoutRaw string `mapstructure:"recursor_timeout" json:"-"`
}
type DNSServer ¶
DNSServer is used to wrap an Agent and expose various service discovery endpoints using a DNS interface.
type DNSServer struct {
*dns.Server
// contains filtered or unexported fields
}
func NewDNSServer ¶
func NewDNSServer(a *Agent) (*DNSServer, error)
func (*DNSServer) ListenAndServe ¶
func (s *DNSServer) ListenAndServe(network, addr string, notif func()) error
type DockerClient ¶
DockerClient defines an interface for a docker client which is used for injecting a fake client during tests.
type DockerClient interface {
CreateExec(docker.CreateExecOptions) (*docker.Exec, error)
StartExec(string, docker.StartExecOptions) error
InspectExec(string) (*docker.ExecInspect, error)
}
type FilePermissions ¶
FilePermissions is an interface which allows a struct to set ownership and permissions easily on a file it describes.
type FilePermissions interface {
// User returns a user ID or user name
User() string
// Group returns a group ID. Group names are not supported.
Group() string
// Mode returns a string of file mode bits e.g. "0644"
Mode() string
}
type HTTPServer ¶
HTTPServer provides an HTTP api for an agent.
type HTTPServer struct {
*http.Server
// contains filtered or unexported fields
}
func NewHTTPServer ¶
func NewHTTPServer(addr string, a *Agent) *HTTPServer
func (*HTTPServer) ACLClone ¶
func (s *HTTPServer) ACLClone(resp http.ResponseWriter, req *http.Request) (interface{}, error)
func (*HTTPServer) ACLCreate ¶
func (s *HTTPServer) ACLCreate(resp http.ResponseWriter, req *http.Request) (interface{}, error)
func (*HTTPServer) ACLDestroy ¶
func (s *HTTPServer) ACLDestroy(resp http.ResponseWriter, req *http.Request) (interface{}, error)
func (*HTTPServer) ACLGet ¶
func (s *HTTPServer) ACLGet(resp http.ResponseWriter, req *http.Request) (interface{}, error)
func (*HTTPServer) ACLList ¶
func (s *HTTPServer) ACLList(resp http.ResponseWriter, req *http.Request) (interface{}, error)
func (*HTTPServer) ACLReplicationStatus ¶
func (s *HTTPServer) ACLReplicationStatus(resp http.ResponseWriter, req *http.Request) (interface{}, error)
func (*HTTPServer) ACLUpdate ¶
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) AgentCheckUpdate ¶
func (s *HTTPServer) AgentCheckUpdate(resp http.ResponseWriter, req *http.Request) (interface{}, error)
AgentCheckUpdate is a PUT-based alternative to the GET-based Pass/Warn/Fail APIs.
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) AgentLeave ¶
func (s *HTTPServer) AgentLeave(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) AgentMonitor ¶
func (s *HTTPServer) AgentMonitor(resp http.ResponseWriter, req *http.Request) (interface{}, error)
func (*HTTPServer) AgentNodeMaintenance ¶
func (s *HTTPServer) AgentNodeMaintenance(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) AgentReload ¶
func (s *HTTPServer) AgentReload(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) AgentServiceMaintenance ¶
func (s *HTTPServer) AgentServiceMaintenance(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) CoordinateDatacenters ¶
func (s *HTTPServer) CoordinateDatacenters(resp http.ResponseWriter, req *http.Request) (interface{}, error)
CoordinateDatacenters returns the WAN nodes in each datacenter, along with raw network coordinates.
func (*HTTPServer) CoordinateNodes ¶
func (s *HTTPServer) CoordinateNodes(resp http.ResponseWriter, req *http.Request) (interface{}, error)
CoordinateNodes returns the LAN nodes in the given datacenter, along with raw network coordinates.
func (*HTTPServer) EventFire ¶
func (s *HTTPServer) EventFire(resp http.ResponseWriter, req *http.Request) (interface{}, error)
EventFire is used to fire a new event
func (*HTTPServer) EventList ¶
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) IsUIEnabled ¶
func (s *HTTPServer) IsUIEnabled() bool
Returns true if the UI is enabled.
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) KeyringInstall ¶
func (s *HTTPServer) KeyringInstall(resp http.ResponseWriter, req *http.Request, args *keyringArgs) (interface{}, error)
KeyringInstall is used to install a new gossip encryption key into the cluster
func (*HTTPServer) KeyringList ¶
func (s *HTTPServer) KeyringList(resp http.ResponseWriter, req *http.Request, args *keyringArgs) (interface{}, error)
KeyringList is used to list the keys installed in the cluster
func (*HTTPServer) KeyringRemove ¶
func (s *HTTPServer) KeyringRemove(resp http.ResponseWriter, req *http.Request, args *keyringArgs) (interface{}, error)
KeyringRemove is used to list the keys installed in the cluster
func (*HTTPServer) KeyringUse ¶
func (s *HTTPServer) KeyringUse(resp http.ResponseWriter, req *http.Request, args *keyringArgs) (interface{}, error)
KeyringUse is used to change the primary gossip encryption key
func (*HTTPServer) OperatorAutopilotConfiguration ¶
func (s *HTTPServer) OperatorAutopilotConfiguration(resp http.ResponseWriter, req *http.Request) (interface{}, error)
OperatorAutopilotConfiguration is used to inspect the current Autopilot configuration. This supports the stale query mode in case the cluster doesn't have a leader.
func (*HTTPServer) OperatorKeyringEndpoint ¶
func (s *HTTPServer) OperatorKeyringEndpoint(resp http.ResponseWriter, req *http.Request) (interface{}, error)
OperatorKeyringEndpoint handles keyring operations (install, list, use, remove)
func (*HTTPServer) OperatorRaftConfiguration ¶
func (s *HTTPServer) OperatorRaftConfiguration(resp http.ResponseWriter, req *http.Request) (interface{}, error)
OperatorRaftConfiguration is used to inspect the current Raft configuration. This supports the stale query mode in case the cluster doesn't have a leader.
func (*HTTPServer) OperatorRaftPeer ¶
func (s *HTTPServer) OperatorRaftPeer(resp http.ResponseWriter, req *http.Request) (interface{}, error)
OperatorRaftPeer supports actions on Raft peers. Currently we only support removing peers by address.
func (*HTTPServer) OperatorServerHealth ¶
func (s *HTTPServer) OperatorServerHealth(resp http.ResponseWriter, req *http.Request) (interface{}, error)
OperatorServerHealth is used to get the health of the servers in the local DC
func (*HTTPServer) PreparedQueryGeneral ¶
func (s *HTTPServer) PreparedQueryGeneral(resp http.ResponseWriter, req *http.Request) (interface{}, error)
PreparedQueryGeneral handles all the general prepared query requests.
func (*HTTPServer) PreparedQuerySpecific ¶
func (s *HTTPServer) PreparedQuerySpecific(resp http.ResponseWriter, req *http.Request) (interface{}, error)
PreparedQuerySpecific handles all the prepared query requests specific to a particular query.
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) SessionRenew ¶
func (s *HTTPServer) SessionRenew(resp http.ResponseWriter, req *http.Request) (interface{}, error)
SessionRenew is used to renew the TTL on an existing TTL session
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) Snapshot ¶
func (s *HTTPServer) Snapshot(resp http.ResponseWriter, req *http.Request) (interface{}, error)
Snapshot handles requests to take and restore snapshots. This uses a special mechanism to make the RPC since we potentially stream large amounts of data as part of these requests.
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) Txn ¶
func (s *HTTPServer) Txn(resp http.ResponseWriter, req *http.Request) (interface{}, error)
Txn handles requests to apply multiple operations in a single, atomic transaction. A transaction consisting of only read operations will be fast- pathed to an endpoint that supports consistency modes (but not blocking), and everything else will be routed through Raft like a normal write.
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 Performance ¶
Performance is used to tune the performance of Consul's subsystems.
type Performance struct {
// RaftMultiplier is an integer multiplier used to scale Raft timing
// parameters: HeartbeatTimeout, ElectionTimeout, and LeaderLeaseTimeout.
RaftMultiplier uint `mapstructure:"raft_multiplier"`
}
type PortConfig ¶
Ports is used to simplify the configuration by providing default ports, and allowing the addresses to only be specified once
type PortConfig struct {
DNS int // DNS Query interface
HTTP int // HTTP API
HTTPS int // HTTPS API
SerfLan int `mapstructure:"serf_lan"` // LAN gossip (Client + Server)
SerfWan int `mapstructure:"serf_wan"` // WAN gossip (Server only)
Server int // Server internal RPC
// RPC is deprecated and is no longer used. It will be removed in a future
// version.
RPC int // CLI RPC
}
type ProtoAddr ¶
type ProtoAddr struct {
Proto, Net, Addr string
}
func (ProtoAddr) String ¶
func (p ProtoAddr) String() string
type RetryJoinAzure ¶
RetryJoinAzure is used to configure discovery of instances via AzureRM API
type RetryJoinAzure struct {
// The tag name and value to use when filtering instances
TagName string `mapstructure:"tag_name"`
TagValue string `mapstructure:"tag_value"`
// The Azure credentials to use for making requests to AzureRM
SubscriptionID string `mapstructure:"subscription_id" json:"-"`
TenantID string `mapstructure:"tenant_id" json:"-"`
ClientID string `mapstructure:"client_id" json:"-"`
SecretAccessKey string `mapstructure:"secret_access_key" json:"-"`
}
type RetryJoinEC2 ¶
RetryJoinEC2 is used to configure discovery of instances via Amazon's EC2 api
type RetryJoinEC2 struct {
// The AWS region to look for instances in
Region string `mapstructure:"region"`
// The tag key and value to use when filtering instances
TagKey string `mapstructure:"tag_key"`
TagValue string `mapstructure:"tag_value"`
// The AWS credentials to use for making requests to EC2
AccessKeyID string `mapstructure:"access_key_id" json:"-"`
SecretAccessKey string `mapstructure:"secret_access_key" json:"-"`
}
type RetryJoinGCE ¶
RetryJoinGCE is used to configure discovery of instances via Google Compute Engine's API.
type RetryJoinGCE struct {
// The name of the project the instances reside in.
ProjectName string `mapstructure:"project_name"`
// A regular expression (RE2) pattern for the zones you want to discover the instances in.
// Example: us-west1-.*, or us-(?west|east).*.
ZonePattern string `mapstructure:"zone_pattern"`
// The tag value to search for when filtering instances.
TagValue string `mapstructure:"tag_value"`
// A path to a JSON file with the service account credentials necessary to
// connect to GCE. If this is not defined, the following chain is respected:
// 1. A JSON file whose path is specified by the
// GOOGLE_APPLICATION_CREDENTIALS environment variable.
// 2. A JSON file in a location known to the gcloud command-line tool.
// On Windows, this is %APPDATA%/gcloud/application_default_credentials.json.
// On other systems, $HOME/.config/gcloud/application_default_credentials.json.
// 3. On Google Compute Engine, it fetches credentials from the metadata
// server. (In this final case any provided scopes are ignored.)
CredentialsFile string `mapstructure:"credentials_file"`
}
type Self ¶
type Self struct {
Config *Config
Coord *coordinate.Coordinate
Member serf.Member
Stats map[string]map[string]string
Meta map[string]string
}
type ServiceDefinition ¶
ServiceDefinition is used to JSON decode the Service definitions
type ServiceDefinition struct {
ID string
Name string
Tags []string
Address string
Port int
Check CheckType
Checks CheckTypes
Token string
EnableTagOverride bool
}
func DecodeServiceDefinition ¶
func DecodeServiceDefinition(raw interface{}) (*ServiceDefinition, error)
DecodeServiceDefinition is used to decode a service definition
func (*ServiceDefinition) CheckTypes ¶
func (s *ServiceDefinition) CheckTypes() (checks CheckTypes)
func (*ServiceDefinition) NodeService ¶
func (s *ServiceDefinition) NodeService() *structs.NodeService
type ServiceSummary ¶
ServiceSummary is used to summarize a service
type ServiceSummary struct {
Name string
Nodes []string
ChecksPassing int
ChecksWarning int
ChecksCritical int
}
type Telemetry ¶
Telemetry is the telemetry configuration for the server
type Telemetry struct {
// StatsiteAddr is the address of a statsite instance. If provided,
// metrics will be streamed to that instance.
StatsiteAddr string `mapstructure:"statsite_address"`
// StatsdAddr is the address of a statsd instance. If provided,
// metrics will be sent to that instance.
StatsdAddr string `mapstructure:"statsd_address"`
// StatsitePrefix is the prefix used to write stats values to. By
// default this is set to 'consul'.
StatsitePrefix string `mapstructure:"statsite_prefix"`
// DisableHostname will disable hostname prefixing for all metrics
DisableHostname bool `mapstructure:"disable_hostname"`
// DogStatsdAddr is the address of a dogstatsd instance. If provided,
// metrics will be sent to that instance
DogStatsdAddr string `mapstructure:"dogstatsd_addr"`
// DogStatsdTags are the global tags that should be sent with each packet to dogstatsd
// It is a list of strings, where each string looks like "my_tag_name:my_tag_value"
DogStatsdTags []string `mapstructure:"dogstatsd_tags"`
// CirconusAPIToken is a valid API Token used to create/manage check. If provided,
// metric management is enabled.
// Default: none
CirconusAPIToken string `mapstructure:"circonus_api_token" json:"-"`
// CirconusAPIApp is an app name associated with API token.
// Default: "consul"
CirconusAPIApp string `mapstructure:"circonus_api_app"`
// CirconusAPIURL is the base URL to use for contacting the Circonus API.
// Default: "https://api.circonus.com/v2"
CirconusAPIURL string `mapstructure:"circonus_api_url"`
// CirconusSubmissionInterval is the interval at which metrics are submitted to Circonus.
// Default: 10s
CirconusSubmissionInterval string `mapstructure:"circonus_submission_interval"`
// CirconusCheckSubmissionURL is the check.config.submission_url field from a
// previously created HTTPTRAP check.
// Default: none
CirconusCheckSubmissionURL string `mapstructure:"circonus_submission_url"`
// CirconusCheckID is the check id (not check bundle id) from a previously created
// HTTPTRAP check. The numeric portion of the check._cid field.
// Default: none
CirconusCheckID string `mapstructure:"circonus_check_id"`
// CirconusCheckForceMetricActivation will force enabling metrics, as they are encountered,
// if the metric already exists and is NOT active. If check management is enabled, the default
// behavior is to add new metrics as they are encoutered. If the metric already exists in the
// check, it will *NOT* be activated. This setting overrides that behavior.
// Default: "false"
CirconusCheckForceMetricActivation string `mapstructure:"circonus_check_force_metric_activation"`
// CirconusCheckInstanceID serves to uniquely identify the metrics coming from this "instance".
// It can be used to maintain metric continuity with transient or ephemeral instances as
// they move around within an infrastructure.
// Default: hostname:app
CirconusCheckInstanceID string `mapstructure:"circonus_check_instance_id"`
// CirconusCheckSearchTag is a special tag which, when coupled with the instance id, helps to
// narrow down the search results when neither a Submission URL or Check ID is provided.
// Default: service:app (e.g. service:consul)
CirconusCheckSearchTag string `mapstructure:"circonus_check_search_tag"`
// CirconusCheckTags is a comma separated list of tags to apply to the check. Note that
// the value of CirconusCheckSearchTag will always be added to the check.
// Default: none
CirconusCheckTags string `mapstructure:"circonus_check_tags"`
// CirconusCheckDisplayName is the name for the check which will be displayed in the Circonus UI.
// Default: value of CirconusCheckInstanceID
CirconusCheckDisplayName string `mapstructure:"circonus_check_display_name"`
// CirconusBrokerID is an explicit broker to use when creating a new check. The numeric portion
// of broker._cid. If metric management is enabled and neither a Submission URL nor Check ID
// is provided, an attempt will be made to search for an existing check using Instance ID and
// Search Tag. If one is not found, a new HTTPTRAP check will be created.
// Default: use Select Tag if provided, otherwise, a random Enterprise Broker associated
// with the specified API token or the default Circonus Broker.
// Default: none
CirconusBrokerID string `mapstructure:"circonus_broker_id"`
// CirconusBrokerSelectTag is a special tag which will be used to select a broker when
// a Broker ID is not provided. The best use of this is to as a hint for which broker
// should be used based on *where* this particular instance is running.
// (e.g. a specific geo location or datacenter, dc:sfo)
// Default: none
CirconusBrokerSelectTag string `mapstructure:"circonus_broker_select_tag"`
}
func (*Telemetry) GoString ¶
func (s *Telemetry) GoString() string
type TestAgent ¶
TestAgent encapsulates an Agent with a default configuration and startup procedure suitable for testing. It panics if there are errors during creation or startup instead of returning errors. It manages a temporary data directory which is removed after shutdown.
type TestAgent struct {
// Name is an optional name of the agent.
Name string
// Config is the agent configuration. If Config is nil then
// TestConfig() is used. If Config.DataDir is set then it is
// the callers responsibility to clean up the data directory.
// Otherwise, a temporary data directory is created and removed
// when Shutdown() is called.
Config *Config
// LogOutput is the sink for the logs. If nil, logs are written
// to os.Stderr.
LogOutput io.Writer
// LogWriter is used for streaming logs.
LogWriter *logger.LogWriter
// DataDir is the data directory which is used when Config.DataDir
// is not set. It is created automatically and removed when
// Shutdown() is called.
DataDir string
// Key is the optional encryption key for the LAN and WAN keyring.
Key string
// NoInitialSync determines whether an anti-entropy run
// will be scheduled after the agent started.
NoInitialSync bool
// Agent is the embedded consul agent.
// It is valid after Start().
*Agent
// contains filtered or unexported fields
}
func NewTestAgent ¶
func NewTestAgent(name string, c *Config) *TestAgent
NewTestAgent returns a started agent with the given name and configuration. It panics if the agent could not be started. The caller should call Shutdown() to stop the agent and remove temporary directories.
func (*TestAgent) Client ¶
func (a *TestAgent) Client() *api.Client
func (*TestAgent) HTTPAddr ¶
func (a *TestAgent) HTTPAddr() string
func (*TestAgent) Shutdown ¶
func (a *TestAgent) Shutdown() error
Shutdown stops the agent and removes the data directory if it is managed by the test agent.
func (*TestAgent) Start ¶
func (a *TestAgent) Start() *TestAgent
Start starts a test agent. It panics if the agent could not be started.
type UnixSocketConfig ¶
UnixSocketConfig stores information about various unix sockets which Consul creates and uses for communication.
type UnixSocketConfig struct {
UnixSocketPermissions `mapstructure:",squash"`
}
type UnixSocketPermissions ¶
UnixSocketPermissions contains information about a unix socket, and implements the FilePermissions interface.
type UnixSocketPermissions struct {
Usr string `mapstructure:"user"`
Grp string `mapstructure:"group"`
Perms string `mapstructure:"mode"`
}
func (UnixSocketPermissions) Group ¶
func (u UnixSocketPermissions) Group() string
func (UnixSocketPermissions) Mode ¶
func (u UnixSocketPermissions) Mode() string
func (UnixSocketPermissions) User ¶
func (u UnixSocketPermissions) User() string
type UserEvent ¶
UserEventParam is used to parameterize a user event
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:"-"`
}