Documentation

Index

Constants

View Source
const (
	// This is where the GCE metadata server normally resides. We hardcode the
	// "instance" path as well since it's the only one we access here.
	DEFAULT_GCE_URL = "http://169.254.169.254/computeMetadata/v1/instance/"

	// GceMetadataTimeout is the timeout used when contacting the GCE metadata
	// service
	GceMetadataTimeout = 2 * time.Second
)
View Source
const (
	EmptyDuration = time.Duration(0)

	// TightenNetworkTimeoutsConfig is a config key that can be used during
	// tests to tighten the timeouts for fingerprinters that make network calls.
	TightenNetworkTimeoutsConfig = "test.tighten_network_timeouts"
)

    EmptyDuration is to be used by fingerprinters that are not periodic.

    View Source
    const (
    	// AwsMetadataTimeout is the timeout used when contacting the AWS metadata
    	// services.
    	AwsMetadataTimeout = 2 * time.Second
    )

    Variables

    This section is empty.

    Functions

    func BuiltinFingerprints

    func BuiltinFingerprints() []string

      BuiltinFingerprints is a slice containing the key names of all registered fingerprints available. The order of this slice should be preserved when fingerprinting.

      func FindCgroupMountpointDir

      func FindCgroupMountpointDir() (string, error)

        FindCgroupMountpointDir is used to find the cgroup mount point on a Linux system.

        Types

        type ArchFingerprint

        type ArchFingerprint struct {
        	StaticFingerprinter
        	// contains filtered or unexported fields
        }

          ArchFingerprint is used to fingerprint the architecture

          func (*ArchFingerprint) Fingerprint

          func (f *ArchFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

          type CGroupFingerprint

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

          func (*CGroupFingerprint) Fingerprint

          func (f *CGroupFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

            Fingerprint tries to find a valid cgroup mount point

            func (*CGroupFingerprint) Periodic

            func (f *CGroupFingerprint) Periodic() (bool, time.Duration)

              Periodic determines the interval at which the periodic fingerprinter will run.

              type CPUFingerprint

              type CPUFingerprint struct {
              	StaticFingerprinter
              	// contains filtered or unexported fields
              }

                CPUFingerprint is used to fingerprint the CPU

                func (*CPUFingerprint) Fingerprint

                func (f *CPUFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                type ConsulFingerprint

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

                  ConsulFingerprint is used to fingerprint for Consul

                  func (*ConsulFingerprint) Fingerprint

                  func (f *ConsulFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                  func (*ConsulFingerprint) Periodic

                  func (f *ConsulFingerprint) Periodic() (bool, time.Duration)

                  type DefaultMountPointDetector

                  type DefaultMountPointDetector struct {
                  }

                    Implements the interface detector which calls the cgroups library directly

                    func (*DefaultMountPointDetector) MountPoint

                    func (b *DefaultMountPointDetector) MountPoint() (string, error)

                      Call out to the default cgroup library

                      type DefaultNetworkInterfaceDetector

                      type DefaultNetworkInterfaceDetector struct {
                      }

                        Implements the interface detector which calls net directly

                        func (*DefaultNetworkInterfaceDetector) Addrs

                        func (*DefaultNetworkInterfaceDetector) InterfaceByName

                        func (b *DefaultNetworkInterfaceDetector) InterfaceByName(name string) (*net.Interface, error)

                        func (*DefaultNetworkInterfaceDetector) Interfaces

                        func (b *DefaultNetworkInterfaceDetector) Interfaces() ([]net.Interface, error)

                        type EnvAWSFingerprint

                        type EnvAWSFingerprint struct {
                        	StaticFingerprinter
                        	// contains filtered or unexported fields
                        }

                          EnvAWSFingerprint is used to fingerprint AWS metadata

                          func (*EnvAWSFingerprint) Fingerprint

                          func (f *EnvAWSFingerprint) Fingerprint(request *FingerprintRequest, response *FingerprintResponse) error

                          type EnvGCEFingerprint

                          type EnvGCEFingerprint struct {
                          	StaticFingerprinter
                          	// contains filtered or unexported fields
                          }

                            EnvGCEFingerprint is used to fingerprint GCE metadata

                            func (*EnvGCEFingerprint) Fingerprint

                            func (f *EnvGCEFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                            func (*EnvGCEFingerprint) Get

                            func (f *EnvGCEFingerprint) Get(attribute string, recursive bool) (string, error)

                            type Factory

                            type Factory func(log.Logger) Fingerprint

                              Factory is used to instantiate a new Fingerprint

                              type Fingerprint

                              type Fingerprint interface {
                              	// Fingerprint is used to update properties of the Node,
                              	// and returns a diff of updated node attributes and a potential error.
                              	Fingerprint(*FingerprintRequest, *FingerprintResponse) error
                              
                              	// Periodic is a mechanism for the fingerprinter to indicate that it should
                              	// be run periodically. The return value is a boolean indicating if it
                              	// should be periodic, and if true, a duration.
                              	Periodic() (bool, time.Duration)
                              }

                                Fingerprint is used for doing "fingerprinting" of the host to automatically determine attributes, resources, and metadata about it. Each of these is a heuristic, and many of them can be applied on a particular host.

                                func NewArchFingerprint

                                func NewArchFingerprint(logger log.Logger) Fingerprint

                                  NewArchFingerprint is used to create an OS fingerprint

                                  func NewCGroupFingerprint

                                  func NewCGroupFingerprint(logger log.Logger) Fingerprint

                                    NewCGroupFingerprint returns a new cgroup fingerprinter

                                    func NewCPUFingerprint

                                    func NewCPUFingerprint(logger log.Logger) Fingerprint

                                      NewCPUFingerprint is used to create a CPU fingerprint

                                      func NewConsulFingerprint

                                      func NewConsulFingerprint(logger log.Logger) Fingerprint

                                        NewConsulFingerprint is used to create a Consul fingerprint

                                        func NewEnvAWSFingerprint

                                        func NewEnvAWSFingerprint(logger log.Logger) Fingerprint

                                          NewEnvAWSFingerprint is used to create a fingerprint from AWS metadata

                                          func NewEnvGCEFingerprint

                                          func NewEnvGCEFingerprint(logger log.Logger) Fingerprint

                                            NewEnvGCEFingerprint is used to create a fingerprint from GCE metadata

                                            func NewFingerprint

                                            func NewFingerprint(name string, logger log.Logger) (Fingerprint, error)

                                              NewFingerprint is used to instantiate and return a new fingerprint given the name and a logger

                                              func NewHostFingerprint

                                              func NewHostFingerprint(logger log.Logger) Fingerprint

                                                NewHostFingerprint is used to create a Host fingerprint

                                                func NewMemoryFingerprint

                                                func NewMemoryFingerprint(logger log.Logger) Fingerprint

                                                  NewMemoryFingerprint is used to create a Memory fingerprint

                                                  func NewNetworkFingerprint

                                                  func NewNetworkFingerprint(logger log.Logger) Fingerprint

                                                    NewNetworkFingerprint returns a new NetworkFingerprinter with the given logger

                                                    func NewNomadFingerprint

                                                    func NewNomadFingerprint(logger log.Logger) Fingerprint

                                                      NewNomadFingerprint is used to create a Nomad fingerprint

                                                      func NewSignalFingerprint

                                                      func NewSignalFingerprint(logger log.Logger) Fingerprint

                                                        NewSignalFingerprint is used to create a Signal fingerprint

                                                        func NewStorageFingerprint

                                                        func NewStorageFingerprint(logger log.Logger) Fingerprint

                                                        func NewVaultFingerprint

                                                        func NewVaultFingerprint(logger log.Logger) Fingerprint

                                                          NewVaultFingerprint is used to create a Vault fingerprint

                                                          type FingerprintRequest

                                                          type FingerprintRequest struct {
                                                          	Config *config.Config
                                                          	Node   *structs.Node
                                                          }

                                                            FingerprintRequest is a request which a fingerprinter accepts to fingerprint the node

                                                            type FingerprintResponse

                                                            type FingerprintResponse struct {
                                                            	Attributes    map[string]string
                                                            	Links         map[string]string
                                                            	Resources     *structs.Resources // COMPAT(0.10): Remove in 0.10
                                                            	NodeResources *structs.NodeResources
                                                            
                                                            	// Detected is a boolean indicating whether the fingerprinter detected
                                                            	// if the resource was available
                                                            	Detected bool
                                                            }

                                                              FingerprintResponse is the response which a fingerprinter annotates with the results of the fingerprint method

                                                              func (*FingerprintResponse) AddAttribute

                                                              func (f *FingerprintResponse) AddAttribute(name, value string)

                                                                AddAttribute adds the name and value for a node attribute to the fingerprint response

                                                                func (f *FingerprintResponse) AddLink(name, value string)

                                                                  AddLink adds a link entry to the fingerprint response

                                                                  func (*FingerprintResponse) RemoveAttribute

                                                                  func (f *FingerprintResponse) RemoveAttribute(name string)

                                                                    RemoveAttribute sets the given attribute to empty, which will later remove it entirely from the node

                                                                    func (f *FingerprintResponse) RemoveLink(name string)

                                                                      RemoveLink removes a link entry from the fingerprint response. This will later remove it entirely from the node

                                                                      type GCEMetadataNetworkInterface

                                                                      type GCEMetadataNetworkInterface struct {
                                                                      	AccessConfigs []struct {
                                                                      		ExternalIp string
                                                                      		Type       string
                                                                      	}
                                                                      	ForwardedIps []string
                                                                      	Ip           string
                                                                      	Network      string
                                                                      }

                                                                      type HealthCheck

                                                                      type HealthCheck interface {
                                                                      	// Check is used to update properties of the node on the status of the health
                                                                      	// check
                                                                      	HealthCheck(*cstructs.HealthCheckRequest, *cstructs.HealthCheckResponse) error
                                                                      
                                                                      	// GetHealthCheckInterval is a mechanism for the health checker to indicate that
                                                                      	// it should be run periodically. The return value is a boolean indicating
                                                                      	// whether it should be done periodically, and the time interval at which
                                                                      	// this check should happen.
                                                                      	GetHealthCheckInterval(*cstructs.HealthCheckIntervalRequest, *cstructs.HealthCheckIntervalResponse) error
                                                                      }

                                                                        HealthCheck is used for doing periodic health checks. On a given time interfal, a health check will be called by the fingerprint manager of the node.

                                                                        type HostFingerprint

                                                                        type HostFingerprint struct {
                                                                        	StaticFingerprinter
                                                                        	// contains filtered or unexported fields
                                                                        }

                                                                          HostFingerprint is used to fingerprint the host

                                                                          func (*HostFingerprint) Fingerprint

                                                                          func (f *HostFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                                                                          type MemoryFingerprint

                                                                          type MemoryFingerprint struct {
                                                                          	StaticFingerprinter
                                                                          	// contains filtered or unexported fields
                                                                          }

                                                                            MemoryFingerprint is used to fingerprint the available memory on the node

                                                                            func (*MemoryFingerprint) Fingerprint

                                                                            func (f *MemoryFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                                                                            type MountPointDetector

                                                                            type MountPointDetector interface {
                                                                            	MountPoint() (string, error)
                                                                            }

                                                                              An interface to isolate calls to the cgroup library This facilitates testing where we can implement fake mount points to test various code paths

                                                                              type NetworkFingerprint

                                                                              type NetworkFingerprint struct {
                                                                              	StaticFingerprinter
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                                NetworkFingerprint is used to fingerprint the Network capabilities of a node

                                                                                func (*NetworkFingerprint) Fingerprint

                                                                                func (f *NetworkFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                                                                                type NetworkInterfaceDetector

                                                                                type NetworkInterfaceDetector interface {
                                                                                	Interfaces() ([]net.Interface, error)
                                                                                	InterfaceByName(name string) (*net.Interface, error)
                                                                                	Addrs(intf *net.Interface) ([]net.Addr, error)
                                                                                }

                                                                                  An interface to isolate calls to various api in net package This facilitates testing where we can implement fake interfaces and addresses to test varios code paths

                                                                                  type NomadFingerprint

                                                                                  type NomadFingerprint struct {
                                                                                  	StaticFingerprinter
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                    NomadFingerprint is used to fingerprint the Nomad version

                                                                                    func (*NomadFingerprint) Fingerprint

                                                                                    func (f *NomadFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                                                                                    type ReqError

                                                                                    type ReqError struct {
                                                                                    	StatusCode int
                                                                                    }

                                                                                    func (ReqError) Error

                                                                                    func (e ReqError) Error() string

                                                                                    type SignalFingerprint

                                                                                    type SignalFingerprint struct {
                                                                                    	StaticFingerprinter
                                                                                    	// contains filtered or unexported fields
                                                                                    }

                                                                                      SignalFingerprint is used to fingerprint the available signals

                                                                                      func (*SignalFingerprint) Fingerprint

                                                                                      func (f *SignalFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                                                                                      type StaticFingerprinter

                                                                                      type StaticFingerprinter struct{}

                                                                                        StaticFingerprinter can be embedded in a struct that has a Fingerprint method to make it non-periodic.

                                                                                        func (*StaticFingerprinter) Periodic

                                                                                        func (s *StaticFingerprinter) Periodic() (bool, time.Duration)

                                                                                        type StorageFingerprint

                                                                                        type StorageFingerprint struct {
                                                                                        	StaticFingerprinter
                                                                                        	// contains filtered or unexported fields
                                                                                        }

                                                                                          StorageFingerprint is used to measure the amount of storage free for applications that the Nomad agent will run on this machine.

                                                                                          func (*StorageFingerprint) Fingerprint

                                                                                          func (f *StorageFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                                                                                          type VaultFingerprint

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

                                                                                            VaultFingerprint is used to fingerprint for Vault

                                                                                            func (*VaultFingerprint) Fingerprint

                                                                                            func (f *VaultFingerprint) Fingerprint(req *FingerprintRequest, resp *FingerprintResponse) error

                                                                                            func (*VaultFingerprint) Periodic

                                                                                            func (f *VaultFingerprint) Periodic() (bool, time.Duration)