Documentation

Index

Constants

View Source
const (
	ConfigSourceLocal configSource = iota
	ConfigSourceRemote
)
View Source
const (
	SerfLANKeyring = "serf/local.keyring"
	SerfWANKeyring = "serf/remote.keyring"
)
View Source
const (
	MaxDNSLabelLength = 63
)
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

View Source
var InvalidDnsRe = regexp.MustCompile(`[^A-Za-z0-9\\-]+`)
View Source
var TempDir = os.TempDir()

    TempDir defines the base dir for temporary directories.

    Functions

    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 FixupCheckType

            func FixupCheckType(raw interface{}) error

            func FixupChecks

            func FixupChecks(raw interface{}, s *structs.Session) error

              FixupChecks is used to handle parsing the JSON body to default-add the Serf health check if they didn't specify any checks, but to allow an empty list to take out the Serf health check. This behavior broke when mapstructure was updated after 0.9.3, likely because we have a type wrapper around the string.

              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 ForwardSignals

                func ForwardSignals(cmd *exec.Cmd, logFn func(error), shutdownCh <-chan struct{})

                  ForwardSignals will fire up a goroutine to forward signals to the given subprocess until the shutdown channel is closed.

                  func GetDNSConfig

                  func GetDNSConfig(conf *config.RuntimeConfig) *dnsConfig

                    GetDNSConfig takes global config and creates the config used by DNS server

                    func LocalConfig

                    func LocalConfig(cfg *config.RuntimeConfig) local.Config

                    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 NewDurationFixer

                      func NewDurationFixer(fields ...string) durationFixer

                      func NodeID

                      func NodeID() string

                      func ParseMetaPair

                      func ParseMetaPair(raw string) (string, string)

                      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 TestACLConfig

                            func TestACLConfig() string

                              TestACLConfig returns a default configuration for testing an agent with ACLs.

                              func TestConfig

                              func TestConfig(sources ...config.Source) *config.RuntimeConfig

                                TestConfig returns a unique default configuration for testing an agent.

                                Types

                                type Agent

                                type Agent struct {
                                
                                	// Output sink for logs
                                	LogOutput io.Writer
                                
                                	// Used for streaming logs to
                                	LogWriter *logger.LogWriter
                                
                                	// In-memory sink used for collecting metrics
                                	MemSink *metrics.InmemSink
                                
                                	// state stores a local representation of the node,
                                	// services and checks. Used for anti-entropy.
                                	State *local.State
                                	// 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 New

                                  func New(c *config.RuntimeConfig) (*Agent, error)

                                  func NewUnstartedAgent

                                  func NewUnstartedAgent(t *testing.T, name string, hcl string) (*Agent, error)

                                  func (*Agent) AddCheck

                                  func (a *Agent) AddCheck(check *structs.HealthCheck, chkType *structs.CheckType, persist bool, token string, source configSource) 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) AddProxy

                                    func (a *Agent) AddProxy(proxy *structs.ConnectManagedProxy, persist, FromFile bool,
                                    	restoredProxyToken string, source configSource) error

                                      AddProxy adds a new local Connect Proxy instance to be managed by the agent.

                                      It REQUIRES that the service that is being proxied is already present in the local state. Note that this is only used for agent-managed proxies so we can ensure that we always make this true. For externally managed and registered proxies we explicitly allow the proxy to be registered first to make bootstrap ordering of a new service simpler but the same is not true here since this is only ever called when setting up a _managed_ proxy which was registered as part of a service registration either from config or HTTP API call.

                                      The restoredProxyToken argument should only be used when restoring proxy definitions from disk; new proxies must leave it blank to get a new token assigned. We need to restore from disk to enable to continue authenticating running proxies that already had that credential injected.

                                      func (*Agent) AddService

                                      func (a *Agent) AddService(service *structs.NodeService, chkTypes []*structs.CheckType, persist bool, token string, source configSource) 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) ConnectAuthorize

                                        func (a *Agent) ConnectAuthorize(token string,
                                        	req *structs.ConnectAuthorizeRequest) (authz bool, reason string, m *cache.ResultMeta, err error)

                                          ConnectAuthorize implements the core authorization logic for Connect. It's in a separate agent method here because we need to re-use this both in our own HTTP API authz endpoint and in the gRPX xDS/ext_authz API for envoy.

                                          The ACL token and the auth request are provided and the auth decision (true means authorized) and reason string are returned.

                                          If the request input is invalid the error returned will be a BadRequestError, if the token doesn't grant necessary access then an acl.ErrPermissionDenied error is returned, otherwise error indicates an unexpected server failure. If access is denied, no error is returned but the first return value is false.

                                          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() (lib.CoordinateSet, error)

                                                      GetLANCoordinate returns the coordinates of this node in the local pools (assumes coordinates are enabled, so check that before calling).

                                                      func (*Agent) GossipEncrypted

                                                      func (a *Agent) GossipEncrypted() bool

                                                      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 last 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 made. It also sets state that agent-local watches use to "ride out" config reloads and bulk updates which might spuriously unload state and reload it again.

                                                                        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.RuntimeConfig) 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) RemoveProxy

                                                                                func (a *Agent) RemoveProxy(proxyID string, persist bool) error

                                                                                  RemoveProxy stops and removes a local proxy instance.

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

                                                                                        func (a *Agent) ShutdownAgent() error

                                                                                          ShutdownAgent is used to hard stop the agent. Should be preceded by Leave to do it gracefully. Should be followed by ShutdownEndpoints to terminate the HTTP and DNS servers as well.

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

                                                                                            func (a *Agent) ShutdownEndpoints()

                                                                                              ShutdownEndpoints terminates the HTTP and DNS servers. Should be preceded by ShutdownAgent.

                                                                                              func (*Agent) SnapshotRPC

                                                                                              func (a *Agent) SnapshotRPC(args *structs.SnapshotRequest, in io.Reader, out io.Writer,
                                                                                              	replyFn structs.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) TranslateAddress

                                                                                                    func (a *Agent) TranslateAddress(dc string, addr string, taggedAddresses map[string]string) string

                                                                                                      TranslateAddress is used to provide the final, translated address for a node, depending on how the agent and the other node are configured. The dc parameter is the dc the datacenter this node is from.

                                                                                                      func (*Agent) TranslateAddresses

                                                                                                      func (a *Agent) TranslateAddresses(dc string, subj interface{})

                                                                                                        TranslateAddresses translates addresses in the given structure into the final, translated address, depending on how the agent and the other node are configured. The dc parameter is the datacenter this structure is from.

                                                                                                        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 BadRequestError

                                                                                                                type BadRequestError struct {
                                                                                                                	Reason string
                                                                                                                }

                                                                                                                  BadRequestError should be returned by a handler when parameters or the payload are not valid

                                                                                                                  func (BadRequestError) Error

                                                                                                                  func (e BadRequestError) Error() string

                                                                                                                  type Blacklist

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

                                                                                                                    Blacklist implements an HTTP endpoint blacklist based on a list of endpoint prefixes which should be blocked.

                                                                                                                    func NewBlacklist

                                                                                                                    func NewBlacklist(prefixes []string) *Blacklist

                                                                                                                      NewBlacklist returns a blacklist for the given list of prefixes.

                                                                                                                      func (*Blacklist) Block

                                                                                                                      func (b *Blacklist) Block(path string) bool

                                                                                                                        Block will return true if the given path is included among any of the blocked prefixes.

                                                                                                                        type CodeWithPayloadError

                                                                                                                        type CodeWithPayloadError struct {
                                                                                                                        	Reason      string
                                                                                                                        	StatusCode  int
                                                                                                                        	ContentType string
                                                                                                                        }

                                                                                                                          CodeWithPayloadError allow returning non HTTP 200 Error codes while not returning PlainText payload

                                                                                                                          func (CodeWithPayloadError) Error

                                                                                                                          func (e CodeWithPayloadError) Error() string

                                                                                                                          type DNSServer

                                                                                                                          type DNSServer struct {
                                                                                                                          	*dns.Server
                                                                                                                          	// 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(a *Agent) (*DNSServer, error)

                                                                                                                            func (*DNSServer) GetTTLForService

                                                                                                                            func (d *DNSServer) GetTTLForService(service string) (time.Duration, bool)

                                                                                                                              GetTTLForService Find the TTL for a given service. return ttl, true if found, 0, false otherwise

                                                                                                                              func (*DNSServer) ListenAndServe

                                                                                                                              func (d *DNSServer) ListenAndServe(network, addr string, notif func()) error

                                                                                                                              type ForbiddenError

                                                                                                                              type ForbiddenError struct {
                                                                                                                              }

                                                                                                                              func (ForbiddenError) Error

                                                                                                                              func (e ForbiddenError) Error() string

                                                                                                                              type HTTPServer

                                                                                                                              type HTTPServer struct {
                                                                                                                              	*http.Server
                                                                                                                              	// contains filtered or unexported fields
                                                                                                                              }

                                                                                                                                HTTPServer provides an HTTP api for an agent.

                                                                                                                                func (*HTTPServer) ACLBootstrap

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

                                                                                                                                  ACLBootstrap is used to perform a one-time ACL bootstrap operation on a cluster to get the first management token.

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

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

                                                                                                                                  func (*HTTPServer) ACLPolicyCreate

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

                                                                                                                                  func (*HTTPServer) ACLPolicyDelete

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

                                                                                                                                  func (*HTTPServer) ACLPolicyList

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

                                                                                                                                  func (*HTTPServer) ACLPolicyRead

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

                                                                                                                                  func (*HTTPServer) ACLPolicyWrite

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

                                                                                                                                  func (*HTTPServer) ACLReplicationStatus

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

                                                                                                                                  func (*HTTPServer) ACLRulesTranslate

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

                                                                                                                                  func (*HTTPServer) ACLRulesTranslateLegacyToken

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

                                                                                                                                  func (*HTTPServer) ACLTokenCRUD

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

                                                                                                                                  func (*HTTPServer) ACLTokenClone

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

                                                                                                                                  func (*HTTPServer) ACLTokenCreate

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

                                                                                                                                  func (*HTTPServer) ACLTokenDelete

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

                                                                                                                                  func (*HTTPServer) ACLTokenGet

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

                                                                                                                                  func (*HTTPServer) ACLTokenList

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

                                                                                                                                  func (*HTTPServer) ACLTokenSelf

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

                                                                                                                                  func (*HTTPServer) ACLTokenSet

                                                                                                                                  func (s *HTTPServer) ACLTokenSet(resp http.ResponseWriter, req *http.Request, tokenID string) (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) AgentConnectAuthorize

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

                                                                                                                                      AgentConnectAuthorize

                                                                                                                                      POST /v1/agent/connect/authorize

                                                                                                                                      Note: when this logic changes, consider if the Intention.Check RPC method also needs to be updated.

                                                                                                                                      func (*HTTPServer) AgentConnectCALeafCert

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

                                                                                                                                        AgentConnectCALeafCert returns the certificate bundle for a service instance. This supports blocking queries to update the returned bundle.

                                                                                                                                        func (*HTTPServer) AgentConnectCARoots

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

                                                                                                                                          AgentConnectCARoots returns the trusted CA roots.

                                                                                                                                          func (*HTTPServer) AgentConnectProxyConfig

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

                                                                                                                                            GET /v1/agent/connect/proxy/:proxy_service_id

                                                                                                                                            Returns the local proxy config for the identified proxy. Requires token= param with the correct local ProxyToken (not ACL token).

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

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

                                                                                                                                              AgentHealthServiceByID return the local Service Health given its ID

                                                                                                                                              func (*HTTPServer) AgentHealthServiceByName

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

                                                                                                                                                AgentHealthServiceByName return the worse status of all the services with given name on an agent

                                                                                                                                                func (*HTTPServer) AgentHost

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

                                                                                                                                                  AgentHost

                                                                                                                                                  GET /v1/agent/host

                                                                                                                                                  Retrieves information about resources available and in-use for the host the agent is running on such as CPU, memory, and disk usage. Requires a operator:read ACL token.

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

                                                                                                                                                  func (s *HTTPServer) AgentMetrics(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) AgentService

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

                                                                                                                                                    GET /v1/agent/service/:service_id

                                                                                                                                                    Returns the service definition for a single local services and allows blocking watch using hash-based blocking.

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

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

                                                                                                                                                    func (*HTTPServer) CatalogConnectServiceNodes

                                                                                                                                                    func (s *HTTPServer) CatalogConnectServiceNodes(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) ConnectCAConfiguration

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

                                                                                                                                                      /v1/connect/ca/configuration

                                                                                                                                                      func (*HTTPServer) ConnectCAConfigurationGet

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

                                                                                                                                                        GEt /v1/connect/ca/configuration

                                                                                                                                                        func (*HTTPServer) ConnectCAConfigurationSet

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

                                                                                                                                                          PUT /v1/connect/ca/configuration

                                                                                                                                                          func (*HTTPServer) ConnectCARoots

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

                                                                                                                                                            GET /v1/connect/ca/roots

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

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

                                                                                                                                                                CoordinateNode returns the LAN node in the given 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) CoordinateUpdate

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

                                                                                                                                                                    CoordinateUpdate inserts or updates the LAN coordinate of a node.

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

                                                                                                                                                                        func (s *HTTPServer) HealthConnectServiceNodes(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) IntentionCheck

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

                                                                                                                                                                            GET /v1/connect/intentions/check

                                                                                                                                                                            func (*HTTPServer) IntentionCreate

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

                                                                                                                                                                              POST /v1/connect/intentions

                                                                                                                                                                              func (*HTTPServer) IntentionEndpoint

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

                                                                                                                                                                                /v1/connection/intentions

                                                                                                                                                                                func (*HTTPServer) IntentionList

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

                                                                                                                                                                                  GET /v1/connect/intentions

                                                                                                                                                                                  func (*HTTPServer) IntentionMatch

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

                                                                                                                                                                                    GET /v1/connect/intentions/match

                                                                                                                                                                                    func (*HTTPServer) IntentionSpecific

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

                                                                                                                                                                                      IntentionSpecific handles the endpoint for /v1/connection/intentions/:id

                                                                                                                                                                                      func (*HTTPServer) IntentionSpecificDelete

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

                                                                                                                                                                                        DELETE /v1/connect/intentions/:id

                                                                                                                                                                                        func (*HTTPServer) IntentionSpecificGet

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

                                                                                                                                                                                          GET /v1/connect/intentions/:id

                                                                                                                                                                                          func (*HTTPServer) IntentionSpecificUpdate

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

                                                                                                                                                                                            PUT /v1/connect/intentions/:id

                                                                                                                                                                                            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 MethodNotAllowedError

                                                                                                                                                                                                                                                  type MethodNotAllowedError struct {
                                                                                                                                                                                                                                                  	Method string
                                                                                                                                                                                                                                                  	Allow  []string
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    MethodNotAllowedError should be returned by a handler when the HTTP method is not allowed.

                                                                                                                                                                                                                                                    func (MethodNotAllowedError) Error

                                                                                                                                                                                                                                                    func (e MethodNotAllowedError) Error() string

                                                                                                                                                                                                                                                    type NotifyGroup

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

                                                                                                                                                                                                                                                      NotifyGroup is used to allow a simple notification mechanism. Channels can be marked as waiting, and when notify is invoked, all the waiting channels get a message and are cleared from the notify list.

                                                                                                                                                                                                                                                      func (*NotifyGroup) Clear

                                                                                                                                                                                                                                                      func (n *NotifyGroup) Clear(ch chan struct{})

                                                                                                                                                                                                                                                        Clear removes a channel from the notify group

                                                                                                                                                                                                                                                        func (*NotifyGroup) Notify

                                                                                                                                                                                                                                                        func (n *NotifyGroup) Notify()

                                                                                                                                                                                                                                                          Notify will do a non-blocking send to all waiting channels, and clear the notify list

                                                                                                                                                                                                                                                          func (*NotifyGroup) Wait

                                                                                                                                                                                                                                                          func (n *NotifyGroup) Wait(ch chan struct{})

                                                                                                                                                                                                                                                            Wait adds a channel to the notify group

                                                                                                                                                                                                                                                            type Self

                                                                                                                                                                                                                                                            type Self struct {
                                                                                                                                                                                                                                                            	Config      interface{}
                                                                                                                                                                                                                                                            	DebugConfig map[string]interface{}
                                                                                                                                                                                                                                                            	Coord       *coordinate.Coordinate
                                                                                                                                                                                                                                                            	Member      serf.Member
                                                                                                                                                                                                                                                            	Stats       map[string]map[string]string
                                                                                                                                                                                                                                                            	Meta        map[string]string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                            type ServiceSummary

                                                                                                                                                                                                                                                            type ServiceSummary struct {
                                                                                                                                                                                                                                                            	Kind            structs.ServiceKind `json:",omitempty"`
                                                                                                                                                                                                                                                            	Name            string
                                                                                                                                                                                                                                                            	Tags            []string
                                                                                                                                                                                                                                                            	Nodes           []string
                                                                                                                                                                                                                                                            	ChecksPassing   int
                                                                                                                                                                                                                                                            	ChecksWarning   int
                                                                                                                                                                                                                                                            	ChecksCritical  int
                                                                                                                                                                                                                                                            	ExternalSources []string
                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              ServiceSummary is used to summarize a service

                                                                                                                                                                                                                                                              type TestAgent

                                                                                                                                                                                                                                                              type TestAgent struct {
                                                                                                                                                                                                                                                              	// Name is an optional name of the agent.
                                                                                                                                                                                                                                                              	Name string
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	HCL string
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// ExpectConfigError can be set to prevent the agent retrying Start on errors
                                                                                                                                                                                                                                                              	// and eventually blowing up with runtime.Goexit. This enables tests to assert
                                                                                                                                                                                                                                                              	// that some specific bit of config actually does prevent startup entirely in
                                                                                                                                                                                                                                                              	// a reasonable way without reproducing a lot of the boilerplate here.
                                                                                                                                                                                                                                                              	ExpectConfigError bool
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// 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.RuntimeConfig
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// 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
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// UseTLS, if true, will disable the HTTP port and enable the HTTPS
                                                                                                                                                                                                                                                              	// one.
                                                                                                                                                                                                                                                              	UseTLS bool
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// Agent is the embedded consul agent.
                                                                                                                                                                                                                                                              	// It is valid after Start().
                                                                                                                                                                                                                                                              	*Agent
                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                func NewTestAgent

                                                                                                                                                                                                                                                                func NewTestAgent(t *testing.T, name string, hcl string) *TestAgent

                                                                                                                                                                                                                                                                  NewTestAgent returns a started agent with the given name and configuration. It fails the test 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) DNSAddr

                                                                                                                                                                                                                                                                  func (a *TestAgent) DNSAddr() string

                                                                                                                                                                                                                                                                  func (*TestAgent) DNSDisableCompression

                                                                                                                                                                                                                                                                  func (a *TestAgent) DNSDisableCompression(b bool)

                                                                                                                                                                                                                                                                    DNSDisableCompression disables compression for all started DNS servers.

                                                                                                                                                                                                                                                                    func (*TestAgent) HTTPAddr

                                                                                                                                                                                                                                                                    func (a *TestAgent) HTTPAddr() string

                                                                                                                                                                                                                                                                    func (*TestAgent) SegmentAddr

                                                                                                                                                                                                                                                                    func (a *TestAgent) SegmentAddr(name string) 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(t *testing.T) *TestAgent

                                                                                                                                                                                                                                                                        Start starts a test agent. It fails the test if the agent could not be started.

                                                                                                                                                                                                                                                                        type UserEvent

                                                                                                                                                                                                                                                                        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

                                                                                                                                                                                                                                                                          Directories

                                                                                                                                                                                                                                                                          Path Synopsis
                                                                                                                                                                                                                                                                          Package ae provides tools to synchronize state between local and remote consul servers.
                                                                                                                                                                                                                                                                          Package ae provides tools to synchronize state between local and remote consul servers.
                                                                                                                                                                                                                                                                          Package cache provides caching features for data from a Consul server.
                                                                                                                                                                                                                                                                          Package cache provides caching features for data from a Consul server.
                                                                                                                                                                                                                                                                          Code generated by mockery v1.0.0
                                                                                                                                                                                                                                                                          Code generated by mockery v1.0.0
                                                                                                                                                                                                                                                                          ca
                                                                                                                                                                                                                                                                          The snapshot endpoint is a special non-RPC endpoint that supports streaming for taking and restoring snapshots for disaster recovery.
                                                                                                                                                                                                                                                                          The snapshot endpoint is a special non-RPC endpoint that supports streaming for taking and restoring snapshots for disaster recovery.
                                                                                                                                                                                                                                                                          fsm
                                                                                                                                                                                                                                                                          Package proxycfg provides a component that monitors local agent state for Connect proxy service registrations and maintains the necessary cache state for those proxies locally.
                                                                                                                                                                                                                                                                          Package proxycfg provides a component that monitors local agent state for Connect proxy service registrations and maintains the necessary cache state for those proxies locally.
                                                                                                                                                                                                                                                                          Package proxy contains logic for agent interaction with proxies, primarily "managed" proxies.
                                                                                                                                                                                                                                                                          Package proxy contains logic for agent interaction with proxies, primarily "managed" proxies.
                                                                                                                                                                                                                                                                          Package servers provides a Manager interface for Manager managed metadata.Server objects.
                                                                                                                                                                                                                                                                          Package servers provides a Manager interface for Manager managed metadata.Server objects.
                                                                                                                                                                                                                                                                          Package xds provides an impementation of a gRPC service that exports Envoy's xDS API for config discovery.
                                                                                                                                                                                                                                                                          Package xds provides an impementation of a gRPC service that exports Envoy's xDS API for config discovery.