thingfulx

type Attribution struct {
	// Name is the name of at attribution
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	// URL  is the URL of  the attribution
	URL                  string   `protobuf:"bytes,2,opt,name=URL,proto3" json:"URL,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Channel struct {
	// URL contains a unique URL for the Channel that must be the URL at which the
	// Channel's data is available
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	// Title contains a unique (if possible) title for the Channel
	Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	// Description contains a human centered description of the Channel if
	// available.
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Webpage contains a human centered web resource where information about the
	// specific device providing the Channel may be found
	Webpage string `protobuf:"bytes,4,opt,name=webpage,proto3" json:"webpage,omitempty"`
	// IndexedAt contains an RFC3339 timestamp showing when the Channel was
	// indexed
	IndexedAt string `protobuf:"bytes,5,opt,name=indexed_at,json=indexedAt,proto3" json:"indexed_at,omitempty"`
	// Location contains the geographical location of the Channel
	Location *Location `protobuf:"bytes,6,opt,name=location,proto3" json:"location,omitempty"`
	// Provider contains information about the data provider
	Provider *Provider `protobuf:"bytes,7,opt,name=provider,proto3" json:"provider,omitempty"`
	// Metadata contains an optional list of metadata about the Channel
	Metadata []*Metadata `protobuf:"bytes,8,rep,name=metadata,proto3" json:"metadata,omitempty"`
	// Visibility returns the visibility status of the Channel. Can be one of OPEN
	// - open API freely accessible with no authentication, SHARED - available via
	// a public API provided suitable authentication is supplied, or CLOSED - only
	// available via a private API. This is a required field.
	Visibility Visibility `protobuf:"varint,9,opt,name=visibility,proto3,enum=thingfulx.protobuf.Visibility" json:"visibility,omitempty"`
	// DataLicense returns the unique identifying URL of a specific data license
	// that the data provider has chosen to apply to their data. This is an
	// optional field.
	DataLicense *DataLicense `protobuf:"bytes,10,opt,name=data_license,json=dataLicense,proto3" json:"data_license,omitempty"`
	// Attributions contains a list of attributions we require to add to a
	// channel. Typically there will only be one, but some providers may require
	// multiple attributions.
	Attributions []*Attribution `protobuf:"bytes,11,rep,name=attributions,proto3" json:"attributions,omitempty"`
	// UpdateInterval returns the update frequency of the data resource expressed
	// as an integer number of seconds.
	UpdateInterval int32 `protobuf:"varint,12,opt,name=update_interval,json=updateInterval,proto3" json:"update_interval,omitempty"`
	// QuantityKind is used to describe the specific physical quantity kind this
	// channel measures. This will be expressed as a namespaced string, i.e.
	// m3-lite:AirTemperature where this compressed string can be expanded to URL
	// that uniquely identifies the quantity kind.
	QuantityKind string `protobuf:"bytes,13,opt,name=quantity_kind,json=quantityKind,proto3" json:"quantity_kind,omitempty"`
	// Unit is used to describe the unit in which the Channel publishes its data.
	// This will be expressed as a namespaced string, i.e. m3-lite:DegreeCelsius
	// which can be expanded to a URL that uniqely identifies the unit, and can be
	// used to obtain the symbol or to do conversions.
	Unit string `protobuf:"bytes,14,opt,name=unit,proto3" json:"unit,omitempty"`
	// DomainOfInterest is used to describe the broad category of the channel, and
	// as above will be expressed as a namespaced string, i.e.
	// m3-lite:Environment, which as above can be expanded.
	DomainOfInterest []string `protobuf:"bytes,15,rep,name=domain_of_interest,json=domainOfInterest,proto3" json:"domain_of_interest,omitempty"`
	// MeasuredBy is used to describe the type of sensor that was used to obtain
	// the channel's data. Expressed as a namespaced string, i.e.
	// m3-lite:Seismometer.
	MeasuredBy string `protobuf:"bytes,16,opt,name=measured_by,json=measuredBy,proto3" json:"measured_by,omitempty"`
	// DataType is used to encode the type of the value contained in each
	// observation.
	DataType DataType `protobuf:"varint,17,opt,name=data_type,json=dataType,proto3,enum=thingfulx.protobuf.DataType" json:"data_type,omitempty"`
	// Observations returns a list of data observation values that represent
	// concrete data recordings for the Channel.
	Observations         []*Observation `protobuf:"bytes,18,rep,name=observations,proto3" json:"observations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

type Client interface {
	// DoHTTP is a thin wrapper around the `Do` method on `net/http.Client`. It
	// simply ensures we set the correct user agent header before making the
	// request. Note that unlike the wrapped standard library method we pass
	// context explicitly as the first parameter.
	DoHTTP(ctx context.Context, req *http.Request) (*http.Response, error)

	// Get is a helper function on the client interface for the most common usage
	// of the Client, making a simple Get request for a given URL, and returning a
	// slice of bytes containing the HTTP response. This uses client.DoHTTP
	// internally so that it ensures the correct user agent string is sent. Note
	// that unlike the wrapped standard library method we pass context explicitly
	// as the first parameter.
	GetHTTP(ctx context.Context, urlStr string) ([]byte, error)

	// PostHTTP defines a function for sending a POST request to a data
	// infrastructure in order to obtain data. Typically we send GET requests, but
	// some infrastructures may require POST requests. This function returns a
	// slice of bytes for any HTTP OK response, and an error for anything else. If
	// you require finer control of this you should use the DoHTTP method directly
	// which returns the http.Response for processing as required. Note that unlike
	// the wrapped standard library method we pass context explicitly as the first
	// parameter.
	PostHTTP(ctx context.Context, urlStr, contentType string, body io.Reader) ([]byte, error)
}

type Clock interface {
	// Now returns the current time as seen by the provider. This could be a fake
	// time for testing time providers.
	Now() time.Time
}

type ContextKey string

type DataLicense struct {
	// Name is a human friendly label or name for the data license.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Url is a unique identifier for the license that should also be the URL
	// where the text of the license is available.
	Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	// LegalCodeUrl is a link to a long or legal version of the license. This may
	// be the same as the above URL if no more detailed version is available.
	LegalCodeUrl string `protobuf:"bytes,3,opt,name=legal_code_url,json=legalCodeUrl,proto3" json:"legal_code_url,omitempty"`
	// Permits is a list of properties which define what usage the license
	// permits.
	Permits []string `protobuf:"bytes,4,rep,name=permits,proto3" json:"permits,omitempty"`
	// Requires is a list of properties which define what requirements the license
	// has.
	Requires []string `protobuf:"bytes,5,rep,name=requires,proto3" json:"requires,omitempty"`
	// Permits is a list of properties which define what the license prohibits
	Prohibits            []string `protobuf:"bytes,6,rep,name=prohibits,proto3" json:"prohibits,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type DataType int32

type DefaultClock struct{}

type ErrBadData struct {
	Msg string
}

type ErrMissingConfig struct {
	Variable string
}

type ErrUnexpectedResponse struct {
	Status string
}

type Error string

type Indexer interface {
	// Provider returns data for the current provider.
	Provider() *Provider

	// URLS returns the smallest set of URLs required to completely index the
	// upstream data provider. The returned values might be a single URL for hosts
	// that publish relatively few things that are all available via a single URL,
	// or it might be hundreds of thousands of values long for hosts that publish
	// data entirely on individual URLs.
	//
	// This function takes as parameters an instance of the Context interface for
	// request-scoped values or cancellation, a Client implementation which the
	// Indexer must use to make any outgoing requests, a delay Duration which
	// defines the minimum interval between consecutive requests to the
	// infrastructure. In addition the caller must pass in a channel by which the
	// function can return data to the caller. This is intended to allow the indexer
	// implementation to return chunks of data as it goes in order to support
	// infrastructures with hundreds of thousands of unique URLs to return.
	URLS(ctx context.Context, client Client, delay time.Duration, out chan<- URLData)

	// Fetch is our method that knows how to obtain raw data for an infrastructure,
	// and is therefore responsible for negotiating any authentication or protocol
	// weirdness when it comes to fetching data. It takes as parameters an instance
	// of the Context interface for request-scoped values and cancellation, the url
	// we want to get data from, a Client object that the indexer must use to
	// actually make the request, and a Clock to allow testing time related
	// functions. It returns the raw data from the infrastructure as a slice of
	// bytes for further parsing.
	Fetch(ctx context.Context, urlStr string, client Client, clock Clock) ([]byte, error)

	// Parse returns a slice of Channel objects extracted from that data source.
	// This function takes as parameters a slice of bytes representing the data
	// collected from the upstream data provider, the URL of the Channel being
	// indexed and a Clock instance used internally by the fetcher to record the
	// indexing time of the parser. This is to allow for easier testing. We
	// separate Parsing from Fetching as we have some systems that provide data to
	// us without having to be fetched from a remote HTTP source.
	Parse(rawData []byte, urlStr string, clock Clock) ([]*Channel, error)
}

type IndexerBuilder func() (Indexer, error)

type Location struct {
	// Longitude contains the decimal longitude of a geographical location
	Longitude float32 `protobuf:"fixed32,1,opt,name=longitude,proto3" json:"longitude,omitempty"`
	// Latitude contains the decimal latitude of a geographical location
	Latitude             float32  `protobuf:"fixed32,2,opt,name=latitude,proto3" json:"latitude,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Metadata struct {
	// Property contains a namespaced property of a channel that we wish to
	// describe.
	Property string `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"`
	// Value contains the value we wish to assign to that property in order to
	// correctly describe some aspect of the Channel
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Observation struct {
	// RecordedAt records the timestamp at which the observation was recorded in
	// UTC and expressed as an RFC3339 string.
	RecordedAt string `protobuf:"bytes,1,opt,name=recorded_at,json=recordedAt,proto3" json:"recorded_at,omitempty"`
	// Each Observation must include its own location as this allows us to place
	// an observation in a particular place at a particular time which may be
	// different from the current location of the Channel.
	Location *Location `protobuf:"bytes,2,opt,name=location,proto3" json:"location,omitempty"`
	// Value includes the actual value of the Observation at the instant of time
	// encoded as a string.
	Value                string   `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type Provider struct {
	// Uid is a unique identifier for the data provider
	Uid string `protobuf:"bytes,1,opt,name=uid,proto3" json:"uid,omitempty"`
	// Name is a human friendly label for the data provider
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// Description is a longer form description of the data provider
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Webpage should contain a link to a public webpage describing the provider
	Webpage              string   `protobuf:"bytes,4,opt,name=webpage,proto3" json:"webpage,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TimeProvider = Clock

type URLData struct {
	// URLS is a slice of url strings representing a chunk of candidate resource
	// URLs for the target infrastructure.
	URLS []string

	// Err is used to allow the process to signal back an error to the caller. We
	// package it with the data so we can signal an error at any point.
	Err error
}

type Visibility int32