xfer

Documentation

Index

• Constants
• Variables
• func AuthorizationHeader(token string) string
• type Adder
• type BackgroundPublisher
  • func NewBackgroundPublisher(p Publisher) *BackgroundPublisher
  • func (bp *BackgroundPublisher) Publish(r io.Reader) error
  • func (bp *BackgroundPublisher) Stop()
• type Collector
  • func NewCollector(window time.Duration) *Collector
  • func (c *Collector) Add(rpt report.Report)
  • func (c *Collector) Report() report.Report
• type HTTPPublisher
  • func NewHTTPPublisher(hostname, target, token, probeID string, insecure bool) (string, *HTTPPublisher, error)
  • func (p HTTPPublisher) Publish(r io.Reader) error
  • func (p *HTTPPublisher) Stop()
  • func (p HTTPPublisher) String() string
• type MultiPublisher
  • func NewMultiPublisher(factory func(hostname, endpoint string) (string, Publisher, error)) *MultiPublisher
  • func (p *MultiPublisher) Delete(target string)
  • func (p *MultiPublisher) Publish(r io.Reader) error
  • func (p *MultiPublisher) Set(target string, endpoints []string)
  • func (p *MultiPublisher) Stop()
• type Publisher
• type ReportPublisher
  • func NewReportPublisher(publisher Publisher) *ReportPublisher
  • func (p *ReportPublisher) Publish(r report.Report) error
• type Reporter

Constants

const ScopeProbeIDHeader = "X-Scope-Probe-ID"

ScopeProbeIDHeader is the header we use to carry the probe's unique ID. The ID is currently set to the probe's hostname. It's designed to deduplicate reports from the same probe to the same receiver, in case the probe is configured to publish to multiple receivers that resolve to the same app.

Variables

var (
	// AppPort is the default port that the app will use for its HTTP server.
	// The app publishes the API and user interface, and receives reports from
	// probes, on this port.
	AppPort = 4040
)

Functions

func AuthorizationHeader

func AuthorizationHeader(token string) string

AuthorizationHeader returns a value suitable for an HTTP Authorization header, based on the passed token string.

Types

type Adder

type Adder interface {
	Add(report.Report)
}

Adder is something that can accept reports. It's a convenient interface for parts of the app, and several experimental components.

type BackgroundPublisher

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

BackgroundPublisher is a publisher which does the publish asynchronously. It will only do one publish at once; if there is an ongoing publish, concurrent publishes are dropped.

func NewBackgroundPublisher

func NewBackgroundPublisher(p Publisher) *BackgroundPublisher

NewBackgroundPublisher creates a new BackgroundPublisher with the given publisher

func (*BackgroundPublisher) Publish

func (bp *BackgroundPublisher) Publish(r io.Reader) error

Publish implements Publisher

func (*BackgroundPublisher) Stop

func (bp *BackgroundPublisher) Stop()

Stop implements Publisher

type Collector

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

Collector receives published reports from multiple producers. It yields a single merged report, representing all collected reports.

func NewCollector

func NewCollector(window time.Duration) *Collector

NewCollector returns a collector ready for use.

func (*Collector) Add

func (c *Collector) Add(rpt report.Report)

Add adds a report to the collector's internal state. It implements Adder.

func (*Collector) Report

func (c *Collector) Report() report.Report

Report returns a merged report over all added reports. It implements Reporter.

type HTTPPublisher

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

HTTPPublisher publishes buffers by POST to a fixed endpoint.

func NewHTTPPublisher

func NewHTTPPublisher(hostname, target, token, probeID string, insecure bool) (string, *HTTPPublisher, error)

NewHTTPPublisher returns an HTTPPublisher ready for use.

func (HTTPPublisher) Publish

func (p HTTPPublisher) Publish(r io.Reader) error

Publish publishes the report to the URL.

func (*HTTPPublisher) Stop

func (p *HTTPPublisher) Stop()

Stop implements Publisher

func (HTTPPublisher) String

func (p HTTPPublisher) String() string

type MultiPublisher

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

MultiPublisher implements publisher over a collection of heterogeneous targets. See documentation of each method to understand the semantics.

func NewMultiPublisher

func NewMultiPublisher(factory func(hostname, endpoint string) (string, Publisher, error)) *MultiPublisher

NewMultiPublisher returns a new MultiPublisher ready for use.

func (*MultiPublisher) Delete

func (p *MultiPublisher) Delete(target string)

Delete removes all endpoints that match the given target.

func (*MultiPublisher) Publish

func (p *MultiPublisher) Publish(r io.Reader) error

Publish implements Publisher by publishing the reader to all of the underlying publishers sequentially. To do that, it needs to drain the reader, and recreate new readers for each publisher. Note that it will publish to one endpoint for each unique ID. Failed publishes don't count.

func (*MultiPublisher) Set

func (p *MultiPublisher) Set(target string, endpoints []string)

Set declares that the target (DNS name) resolves to the provided endpoints (IPs), and that we want to publish to each of those endpoints. Set replaces any existing publishers to the given target. Set invokes the factory method to convert each endpoint to a publisher, and to get the remote receiver's unique ID.

func (*MultiPublisher) Stop

func (p *MultiPublisher) Stop()

Stop invokes stop on all underlying publishers and removes them.

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) *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 Reporter

type Reporter interface {
	Report() report.Report
}

Reporter is something that can produce reports on demand. It's a convenient interface for parts of the app, and several experimental components.