xfer

Documentation

Index

• Constants
• Variables
• type AppClient
  • func NewAppClient(pc ProbeConfig, hostname, target string, control ControlHandler) (AppClient, error)
• type ClientFactory
• type ControlHandler
• type ControlHandlerFunc
  • func (c ControlHandlerFunc) Handle(req Request, res *Response) error
• type Details
• type JSONWebsocketCodec
  • func NewJSONWebsocketCodec(conn *websocket.Conn) *JSONWebsocketCodec
  • func (j *JSONWebsocketCodec) Close() error
  • func (j *JSONWebsocketCodec) ReadRequestBody(v interface{}) error
  • func (j *JSONWebsocketCodec) ReadRequestHeader(r *rpc.Request) error
  • func (j *JSONWebsocketCodec) ReadResponseBody(v interface{}) error
  • func (j *JSONWebsocketCodec) ReadResponseHeader(r *rpc.Response) error
  • func (j *JSONWebsocketCodec) WaitForReadError()
  • func (j *JSONWebsocketCodec) WriteRequest(r *rpc.Request, v interface{}) error
  • func (j *JSONWebsocketCodec) WriteResponse(r *rpc.Response, v interface{}) error
• type Message
• type MultiAppClient
  • func NewMultiAppClient(clientFactory ClientFactory) MultiAppClient
• type Pipe
  • func NewPipe() Pipe
• type ProbeConfig
• type Publisher
• type ReportPublisher
  • func NewReportPublisher(publisher Publisher) *ReportPublisher
  • func (p *ReportPublisher) Publish(r report.Report) error
• type Request
• type Resolver
  • func NewStaticResolver(targets []string, setters ...setter) Resolver
• type Response
  • func ResponseError(err error) Response
  • func ResponseErrorf(format string, a ...interface{}) Response

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 a random string on probe startup.

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
)

Types

type AppClient

type AppClient interface {
	Details() (Details, error)
	ControlConnection()
	PipeConnection(string, 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 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 ControlHandler

type ControlHandler interface {
	Handle(req Request, res *Response) error
}

ControlHandler is interface used in the app and the probe to represent a control RPC.

type ControlHandlerFunc

type ControlHandlerFunc func(Request) Response

ControlHandlerFunc is a adapter (ala golang's http RequestHandlerFunc) for ControlHandler

func (ControlHandlerFunc) Handle

func (c ControlHandlerFunc) Handle(req Request, res *Response) error

Handle is an adapter method to make ControlHandlers exposable via golang rpc

type Details

type Details struct {
	ID       string `json:"id"`
	Version  string `json:"version"`
	Hostname string `json:"hostname"`
}

Details are some generic details that can be fetched from /api

type JSONWebsocketCodec

type JSONWebsocketCodec struct {
	sync.Mutex
	// contains filtered or unexported fields
}

JSONWebsocketCodec is golang rpc compatible Server and Client Codec that transmits and receives RPC messages over a websocker, as JSON.

func NewJSONWebsocketCodec

func NewJSONWebsocketCodec(conn *websocket.Conn) *JSONWebsocketCodec

NewJSONWebsocketCodec makes a new JSONWebsocketCodec

func (*JSONWebsocketCodec) Close

func (j *JSONWebsocketCodec) Close() error

Close implements rpc.ClientCodec and rpc.ServerCodec

func (*JSONWebsocketCodec) ReadRequestBody

func (j *JSONWebsocketCodec) ReadRequestBody(v interface{}) error

ReadRequestBody implements rpc.ServerCodec

func (*JSONWebsocketCodec) ReadRequestHeader

func (j *JSONWebsocketCodec) ReadRequestHeader(r *rpc.Request) error

ReadRequestHeader implements rpc.ServerCodec

func (*JSONWebsocketCodec) ReadResponseBody

func (j *JSONWebsocketCodec) ReadResponseBody(v interface{}) error

ReadResponseBody implements rpc.ClientCodec

func (*JSONWebsocketCodec) ReadResponseHeader

func (j *JSONWebsocketCodec) ReadResponseHeader(r *rpc.Response) error

ReadResponseHeader implements rpc.ClientCodec

func (*JSONWebsocketCodec) WaitForReadError

func (j *JSONWebsocketCodec) WaitForReadError()

WaitForReadError blocks until any read on this codec returns an error. This is useful to know when the server has disconnected from the client.

func (*JSONWebsocketCodec) WriteRequest

func (j *JSONWebsocketCodec) WriteRequest(r *rpc.Request, v interface{}) error

WriteRequest implements rpc.ClientCodec

func (*JSONWebsocketCodec) WriteResponse

func (j *JSONWebsocketCodec) WriteResponse(r *rpc.Response, v interface{}) error

WriteResponse implements rpc.ServerCodec

type Message

type Message struct {
	Request  *rpc.Request
	Response *rpc.Response
	Value    interface{}
}

Message is the unions of Request, Response and PipeIO

type MultiAppClient

type MultiAppClient interface {
	Set(hostname string, endpoints []string)
	PipeConnection(appID, pipeID string, pipe 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) MultiAppClient

NewMultiAppClient creates a new MultiAppClient.

type Pipe

type Pipe interface {
	Ends() (io.ReadWriter, io.ReadWriter)
	CopyToWebsocket(io.ReadWriter, *websocket.Conn) error

	Close() error
	Closed() bool
	OnClose(func())
}

Pipe is a bi-directional channel from someone thing in the probe to the UI.

func NewPipe

func NewPipe() Pipe

NewPipe makes a new... pipe.

type ProbeConfig

type ProbeConfig struct {
	Token    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) *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 Request

type Request struct {
	AppID   string
	NodeID  string
	Control string
}

Request is the UI -> App -> Probe message type for control RPCs

type Resolver

type Resolver interface {
	Stop()
}

Resolver is a thing that can be stopped...

func NewStaticResolver

func NewStaticResolver(targets []string, setters ...setter) Resolver

NewStaticResolver periodically resolves the targets, and calls the set function with all the resolved IPs. It explictiy supports targets which resolve to multiple IPs.

type Response

type Response struct {
	Value  interface{} `json:"value,omitempty"`
	Error  string      `json:"error,omitempty"`
	Pipe   string      `json:"pipe,omitempty"`
	RawTTY bool        `json:"raw_tty,omitempty"`
}

Response is the Probe -> App -> UI message type for the control RPCs.

func ResponseError

func ResponseError(err error) Response

ResponseError creates a new Response with the given error.

func ResponseErrorf

func ResponseErrorf(format string, a ...interface{}) Response

ResponseErrorf creates a new Response with the given formatted error string.