appclient

Documentation

Index

• func LookupUsing(dnsServer string) func(host string) (ips []net.IP, err error)
• type AppClient
  • func NewAppClient(pc ProbeConfig, hostname, target string, control xfer.ControlHandler) (AppClient, error)
• type ClientFactory
• type LookupIP
• type MultiAppClient
  • func NewMultiAppClient(clientFactory ClientFactory, noControls bool) MultiAppClient
• type ProbeConfig
• type Publisher
• type ReportPublisher
  • func NewReportPublisher(publisher Publisher, noControls bool) *ReportPublisher
  • func (p *ReportPublisher) Publish(r report.Report) error
• type Resolver
  • func NewResolver(targets []string, lookup LookupIP, setters ...setter) Resolver

Functions

func LookupUsing

func LookupUsing(dnsServer string) func(host string) (ips []net.IP, err error)

LookupUsing produces a LookupIP function for the given DNS server.

Types

type AppClient

type AppClient interface {
	Details() (xfer.Details, error)
	ControlConnection()
	PipeConnection(string, xfer.Pipe)
	PipeClose(string) error
	Publish(r io.Reader) error
	Stop()
}

AppClient is a client to an app for dealing with controls.

func NewAppClient

func NewAppClient(pc ProbeConfig, hostname, target string, control xfer.ControlHandler) (AppClient, error)

NewAppClient makes a new appClient.

type ClientFactory

type ClientFactory func(string, string) (AppClient, error)

ClientFactory is a thing thats makes AppClients

type LookupIP

type LookupIP func(host string) (ips []net.IP, err error)

LookupIP type is used for looking up IPs.

type MultiAppClient

type MultiAppClient interface {
	Set(hostname string, endpoints []string)
	PipeConnection(appID, pipeID string, pipe xfer.Pipe) error
	PipeClose(appID, pipeID string) error
	Stop()
	Publish(io.Reader) error
}

MultiAppClient maintains a set of upstream apps, and ensures we have an AppClient for each one.

func NewMultiAppClient

func NewMultiAppClient(clientFactory ClientFactory, noControls bool) MultiAppClient

NewMultiAppClient creates a new MultiAppClient.

type ProbeConfig

type ProbeConfig struct {
	Token        string
	ProbeVersion string
	ProbeID      string
	Insecure     bool
}

ProbeConfig contains all the info needed for a probe to do HTTP requests

type Publisher

type Publisher interface {
	Publish(io.Reader) error
	Stop()
}

Publisher is something which can send a stream of data somewhere, probably to a remote collector.

type ReportPublisher

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

A ReportPublisher uses a buffer pool to serialise reports, which it then passes to a publisher

func NewReportPublisher

func NewReportPublisher(publisher Publisher, noControls bool) *ReportPublisher

NewReportPublisher creates a new report publisher

func (*ReportPublisher) Publish

func (p *ReportPublisher) Publish(r report.Report) error

Publish serialises and compresses a report, then passes it to a publisher

type Resolver

type Resolver interface {
	Stop()
}

Resolver is a thing that can be stopped...

func NewResolver

func NewResolver(targets []string, lookup LookupIP, setters ...setter) Resolver

NewResolver periodically resolves the targets, and calls the set function with all the resolved IPs. It explictiy supports targets which resolve to multiple IPs. It uses the supplied DNS server name.