host

Documentation

Index

• Constants
• Variables
• type Reporter
  • func NewReporter(hostID, hostName string, localNets report.Networks) *Reporter
  • func (r *Reporter) Report() (report.Report, error)
• type Tagger
  • func NewTagger(hostID string) Tagger
  • func (t Tagger) Tag(r report.Report) (report.Report, error)

Constants

const (
	Timestamp     = "ts"
	HostName      = "host_name"
	LocalNetworks = "local_networks"
	OS            = "os"
	Load          = "load"
	KernelVersion = "kernel_version"
	Uptime        = "uptime"
)

Keys for use in Node.Metadata.

const (
	ProcUptime = "/proc/uptime"
	ProcLoad   = "/proc/loadavg"
)

Exposed for testing.

Variables

var GetKernelVersion = func() (string, error) {
	var utsname syscall.Utsname
	if err := Uname(&utsname); err != nil {
		return "unknown", err
	}
	return fmt.Sprintf("%s %s", charsToString(utsname.Release), charsToString(utsname.Version)), nil
}

GetKernelVersion returns the kernel version as reported by uname.

var GetLoad = func() string {
	buf, err := ioutil.ReadFile("/proc/loadavg")
	if err != nil {
		return "unknown"
	}
	toks := strings.Fields(string(buf))
	if len(toks) < 3 {
		return "unknown"
	}
	one, err := strconv.ParseFloat(toks[0], 64)
	if err != nil {
		return "unknown"
	}
	five, err := strconv.ParseFloat(toks[1], 64)
	if err != nil {
		return "unknown"
	}
	fifteen, err := strconv.ParseFloat(toks[2], 64)
	if err != nil {
		return "unknown"
	}
	return fmt.Sprintf("%.2f %.2f %.2f", one, five, fifteen)
}

GetLoad returns the current load averages in standard form.

var GetUptime = func() (time.Duration, error) {
	buf, err := ioutil.ReadFile("/proc/uptime")
	if err != nil {
		return 0, err
	}

	fields := strings.Fields(string(buf))
	if len(fields) != 2 {
		return 0, fmt.Errorf("invalid format: %s", string(buf))
	}

	uptime, err := strconv.ParseFloat(fields[0], 64)
	if err != nil {
		return 0, err
	}

	return time.Duration(uptime) * time.Second, nil
}

GetUptime returns the uptime of the host.

var (
	Now = func() string { return time.Now().UTC().Format(time.RFC3339Nano) }
)

Exposed for testing.

var Uname = syscall.Uname

Uname is swappable for mocking in tests.

Types

type Reporter

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

Reporter generates Reports containing the host topology.

func NewReporter

func NewReporter(hostID, hostName string, localNets report.Networks) *Reporter

NewReporter returns a Reporter which produces a report containing host topology for this host.

func (*Reporter) Report

func (r *Reporter) Report() (report.Report, error)

Report implements Reporter.

type Tagger

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

Tagger tags each node in each topology of a report with the origin host node ID of this (probe) host. Effectively, a foreign key linking every node in every topology to an origin host node in the host topology.

func NewTagger

func NewTagger(hostID string) Tagger

NewTagger tags each node with a foreign key linking it to its origin host in the host topology.

func (Tagger) Tag

func (t Tagger) Tag(r report.Report) (report.Report, error)

Tag implements Tagger.