storage

type Cluster interface {
	// Name is the name of the cluster
	Name() string

	// Type is the storage type for the cluster
	Type() Type

	// Config is the cluster's configuration
	Config() Config

	// Database is the name of the database to which the cluster belongs
	Database() string
}

type ClusterMappingProvider interface {
	xclose.Closer

	// QueryMappings returns the active cluster mappings for the given query
	QueryMappings(shard uint32, start, end time.Time) (MappingRuleIter, error)

	// WatchCluster returns the config for a cluster as a watch that can
	// be used to listen for updates to that cluster.  Callers must wait
	// on the watch channel before attempting to access the Cluster
	WatchCluster(database, cluster string) (ClusterWatch, error)
}

type ClusterWatch interface {
	xclose.Closer

	// C is the channel receiving notifications of config changes
	C() <-chan struct{}

	// Get returns the current state of the cluster
	Get() Cluster
}

type Config interface {
	// Version is the version of the configuration
	Version() int

	// Unmarshal unmarshals the configuration
	Unmarshal(c proto.Message) error
}

type Connection interface {
	xclose.Closer

	// Read reads datapoints for the given id at the given time range and resolution
	Read(id string, r retention.Resolution, start, end time.Time) (SeriesIter, error)

	// Write writes a datapoint for the given id at the given time range
	Write(id string, r retention.Resolution, t time.Time, value float64) error
}

type ConnectionManager interface {
	xclose.Closer

	// GetConnection retrieves the connection to the given database and cluster
	GetConnection(database, cluster string) (Connection, error)
}

type ConnectionManagerOptions interface {
	// Logger is the logger to use
	Logger(log xlog.Logger) ConnectionManagerOptions
	GetLogger() xlog.Logger

	// Provider provides information about active clusters
	Provider(p ClusterMappingProvider) ConnectionManagerOptions
	GetProvider() ClusterMappingProvider

	// Drivers are the set of drivers used by this ConnectionManager
	Drivers(d []Driver) ConnectionManagerOptions
	GetDrivers() []Driver

	// Validate validates the options
	Validate() error
}

type Database interface {
	// Name is the name of the database
	Name() string

	// MaxRetention is the maximum amount of type datapoints will be retained in
	// this database
	MaxRetention() time.Duration
}

type Downsampler interface {
	// Init initializes the downsampler to store results in the given values
	Init(vals SeriesValues)

	// AddSample adds a datapoint sample to the given interval
	AddSample(n int, v float64)

	// Finish tells the downsampler we're complete and the final values
	// computed (if they are not already)
	Finish()
}

type Driver interface {
	xclose.Closer

	// ConfigType returns an empty proto.Message representing the configuration
	// type used by the driver
	ConfigType() proto.Message

	// Type is the type of storage supported by the driver
	Type() Type

	// OpenConnection opens a connection with the provided config
	OpenConnection(config proto.Message) (Connection, error)

	// ReconfigureConnection applies a new configuration to an existing connection.
	// Connections could be heavyweight objects, and drivers may wish to optimize
	// reconfiguration to avoid creating and destroying them.  Drivers that do
	// not support dynamic reconfiguration can create a new Connection and dispose
	// of the old connection
	ReconfigureConnection(c Connection, newConfig proto.Message) (Connection, error)
}

type Float64SeriesValues []float64

type Manager interface {
	// Query reads datapoints for the id between two times
	Query(id string, start, end time.Time, ds Downsampler) (QueryResult, error)
}

type MappingRuleIter interface {
	xclose.Closer

	// Next moves to the next mapping, returning false if there are no more
	// mappings
	Next() bool

	// Current returns the current mapping
	Current() mapping.Rule
}

type QueryResult interface {
	// Resolution is the resolution of the returned series
	Resolution() retention.Resolution

	// Series contains the returned data
	Series() Series
}

type Series interface {
	xclose.Closer

	Len() int                    // Len returns the number of datapoints in the series
	StepSize() time.Duration     // StepSize is the size of each "step" in the series
	StartTime() time.Time        // StartTime is the start time for the series
	EndTime() time.Time          // EndTime is the end time for the series
	ValueAt(n int) float64       // ValueAt returns the value at the given step
	StartTimeAt(n int) time.Time // StartTimeAt returns the start time for the given step
}

type SeriesIter interface {
	xclose.Closer

	// Next returns true if there is more data in the series
	Next() bool

	// Current returns the value and timestamp for the current datapoint
	Current() (float64, time.Time)
}

type SeriesValues interface {
	Len() int                    // the number of values in the series
	SetValueAt(n int, v float64) // sets the value at the given location
	ValueAt(n int) float64       // returns the value at the given location
}

type SeriesValuesPool interface {
	// New creates or reserves series values of the specified length
	New(len int) SeriesValues

	// Release releases previously allocated values
	Release(v SeriesValues)
}

type Type interface {
	// Name is the name of the storage type
	Name() string
}