m3

type AggregatedClusterNamespaceDefinition struct {
	NamespaceID ident.ID
	Session     client.Session
	Retention   time.Duration
	Resolution  time.Duration
	Downsample  *ClusterNamespaceDownsampleOptions
	DataLatency time.Duration
	ReadOnly    bool
}

type BlockSeriesProcessor interface {
	Process(bl block.Block, opts Options, fn BlockSeriesProcessorFn) error
}

type BlockSeriesProcessorFn func(
	iter block.SeriesIter,
) error

type Cleanup func() error

type ClusterConfigType int

type ClusterNamespace interface {
	NamespaceID() ident.ID
	Options() ClusterNamespaceOptions
	Session() client.Session
}

type ClusterNamespaceDownsampleOptions struct {
	All bool
}

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

type ClusterNamespaces []ClusterNamespace

type ClusterNamespacesListener interface {
	// OnUpdate is called when updates have occurred passing in the new namespaces.
	OnUpdate(namespaces ClusterNamespaces)
}

type ClusterNamespacesWatcher interface {
	// Update updates the current namespaces.
	Update(namespaces ClusterNamespaces) error

	// Get returns the current namespaces.
	Get() ClusterNamespaces

	// RegisterListener registers a listener for updates to cluster namespaces.
	// If a value is currently present, it will synchronously call back the listener.
	RegisterListener(listener ClusterNamespacesListener) xresource.SimpleCloser

	// Close closes the watcher and all descendent watches.
	Close()
}

type ClusterStaticConfiguration struct {
	NewClientFromConfig NewClientFromConfig                   `yaml:"-"`
	Namespaces          []ClusterStaticNamespaceConfiguration `yaml:"namespaces"`
	Client              client.Configuration                  `yaml:"client"`
}

type ClusterStaticNamespaceConfiguration struct {
	// Namespace is namespace in the cluster that is specified.
	Namespace string `yaml:"namespace"`

	// Type is the type of values stored by the namespace, current
	// supported values are "unaggregated" or "aggregated".
	Type storagemetadata.MetricsType `yaml:"type"`

	// Retention is the length of which values are stored by the namespace.
	Retention time.Duration `yaml:"retention" validate:"nonzero"`

	// Resolution is the frequency of which values are stored by the namespace.
	Resolution time.Duration `yaml:"resolution" validate:"min=0"`

	// Downsample is the configuration for downsampling options to use with
	// the namespace.
	Downsample *DownsampleClusterStaticNamespaceConfiguration `yaml:"downsample"`

	// ReadOnly prevents any writes to this namespace.
	ReadOnly bool `yaml:"readOnly"`

	// DataLatency is the duration after which the data is available in this namespace.
	DataLatency time.Duration `yaml:"dataLatency"`
}

type Clusters interface {
	io.Closer

	// ClusterNamespaces returns all known and ready cluster namespaces.
	ClusterNamespaces() ClusterNamespaces

	// NonReadyClusterNamespaces returns all cluster namespaces not in the ready state.
	NonReadyClusterNamespaces() ClusterNamespaces

	// UnaggregatedClusterNamespace returns the valid unaggregated
	// cluster namespace. If the namespace is not yet initialized, returns false.
	UnaggregatedClusterNamespace() (ClusterNamespace, bool)

	// AggregatedClusterNamespace returns an aggregated cluster namespace
	// at a specific retention and resolution.
	AggregatedClusterNamespace(attrs RetentionResolution) (ClusterNamespace, bool)

	// ConfigType returns the type of configuration used to create this Clusters
	// object.
	ConfigType() ClusterConfigType
}

type ClustersStaticConfiguration []ClusterStaticConfiguration

type ClustersStaticConfigurationOptions struct {
	AsyncSessions      bool
	ProvidedSession    client.Session
	CustomAdminOptions []client.CustomAdminOption
	EncodingOptions    encoding.Options
}

type DownsampleClusterStaticNamespaceConfiguration struct {
	All bool `yaml:"all"`
}

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

type DynamicClusterOptions interface {
	// Validate validates the DynamicClusterOptions.
	Validate() error

	// SetDynamicClusterNamespaceConfiguration sets the configuration for the dynamically fetching cluster namespaces.
	SetDynamicClusterNamespaceConfiguration(value []DynamicClusterNamespaceConfiguration) DynamicClusterOptions

	// DynamicClusterNamespaceConfiguration returns the configuration for the dynamically fetching cluster namespaces.
	DynamicClusterNamespaceConfiguration() []DynamicClusterNamespaceConfiguration

	// SetInstrumentOptions sets the instrument options.
	SetInstrumentOptions(value instrument.Options) DynamicClusterOptions

	// InstrumentOptions returns the instrument options.
	InstrumentOptions() instrument.Options

	// SetClusterNamespacesWatcher sets the namespaces watcher which alerts components that
	// need to regenerate configuration when the ClusterNamespaces change.
	SetClusterNamespacesWatcher(value ClusterNamespacesWatcher) DynamicClusterOptions

	// ClusterNamespacesWatcher returns the namespaces watcher which alerts components that
	// need to regenerate configuration when the ClusterNamespaces change.
	ClusterNamespacesWatcher() ClusterNamespacesWatcher
}

type GraphiteBlockIteratorsFn func(
	block.Block,
) ([]block.SeriesIterBatch, error)

type IteratorBatchingFn func(
	concurrency int,
	seriesBlockIterators []encoding.SeriesIterator,
	seriesMetas []block.SeriesMeta,
	meta block.Metadata,
	opts Options,
) ([]block.SeriesIterBatch, error)

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

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

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

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

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

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

type NewClientFromConfig func(
	cfg client.Configuration,
	params client.ConfigurationParameters,
	custom ...client.CustomAdminOption,
) (client.Client, error)

type Options interface {
	// SetSplitSeriesByBlock determines if the converter will split the series
	// by blocks, or if it will instead treat the entire series as a single block.
	SetSplitSeriesByBlock(bool) Options
	// SplittingSeriesByBlock returns true iff lookback duration is 0, and the
	// options has not been forced to return a single block.
	SplittingSeriesByBlock() bool
	// SetLookbackDuration sets the lookback duration.
	SetLookbackDuration(time.Duration) Options
	// LookbackDuration returns the lookback duration.
	LookbackDuration() time.Duration
	// SetConsolidationFunc sets the consolidation function for the converter.
	SetConsolidationFunc(consolidators.ConsolidationFunc) Options
	// ConsolidationFunc returns the consolidation function.
	ConsolidationFunc() consolidators.ConsolidationFunc
	// SetTagOptions sets the tag options for the converter.
	SetTagOptions(models.TagOptions) Options
	// TagOptions returns the tag options.
	TagOptions() models.TagOptions
	// TagsTransform returns the transform to apply to tags before storage.
	TagsTransform() TagsTransform
	// SetTagsTransform sets the TagsTransform.
	SetTagsTransform(value TagsTransform) Options
	// SetRateLimiter sets the RateLimiter
	SetRateLimiter(value RateLimiter) Options
	// RateLimiter returns the rate limiter.
	RateLimiter() RateLimiter
	// SetIteratorPools sets the iterator pools for the converter.
	SetIteratorPools(encoding.IteratorPools) Options
	// IteratorPools returns the iterator pools for the converter.
	IteratorPools() encoding.IteratorPools
	// SetCheckedBytesPool sets the checked bytes pool for the converter.
	SetCheckedBytesPool(pool.CheckedBytesPool) Options
	// CheckedBytesPool returns the checked bytes pools for the converter.
	CheckedBytesPool() pool.CheckedBytesPool
	// SetReadWorkerPool sets the read worker pool for the converter.
	SetReadWorkerPool(sync.PooledWorkerPool) Options
	// ReadWorkerPool returns the read worker pool for the converter.
	ReadWorkerPool() sync.PooledWorkerPool
	// SetWriteWorkerPool sets the write worker pool for the converter.
	SetWriteWorkerPool(sync.PooledWorkerPool) Options
	// WriteWorkerPool returns the write worker pool for the converter.
	WriteWorkerPool() sync.PooledWorkerPool
	// SetSeriesConsolidationMatchOptions sets series consolidation options.
	SetSeriesConsolidationMatchOptions(value consolidators.MatchOptions) Options
	// SeriesConsolidationMatchOptions sets series consolidation options.
	SeriesConsolidationMatchOptions() consolidators.MatchOptions
	// SetSeriesIteratorProcessor sets the series iterator processor.
	SetSeriesIteratorProcessor(SeriesIteratorProcessor) Options
	// SeriesIteratorProcessor returns the series iterator processor.
	SeriesIteratorProcessor() SeriesIteratorProcessor
	// SetIteratorBatchingFn sets the batching function for the converter.
	SetIteratorBatchingFn(IteratorBatchingFn) Options
	// IteratorBatchingFn returns the batching function for the converter.
	IteratorBatchingFn() IteratorBatchingFn
	// SetBlockSeriesProcessor set the block series processor.
	SetBlockSeriesProcessor(value BlockSeriesProcessor) Options
	// BlockSeriesProcessor returns the block series processor.
	BlockSeriesProcessor() BlockSeriesProcessor
	// SetCustomAdminOptions sets custom admin options.
	SetCustomAdminOptions([]client.CustomAdminOption) Options
	// CustomAdminOptions gets custom admin options.
	CustomAdminOptions() []client.CustomAdminOption
	// SetInstrumented marks if the encoding step should have instrumentation enabled.
	SetInstrumented(bool) Options
	// Instrumented returns if the encoding step should have instrumentation enabled.
	Instrumented() bool
	// SetPromConvertOptions sets options for converting raw series iterators
	// to a Prometheus-compatible result.
	SetPromConvertOptions(storage.PromConvertOptions) Options
	// PromConvertOptions returns options for converting raw series iterators
	// to a Prometheus-compatible result.
	PromConvertOptions() storage.PromConvertOptions
	// Validate ensures that the given block options are valid.
	Validate() error
}

type Querier interface {
	// FetchCompressedResult fetches timeseries data based on a query.
	FetchCompressedResult(
		ctx context.Context,
		query *storage.FetchQuery,
		options *storage.FetchOptions,
	) (consolidators.SeriesFetchResult, Cleanup, error)

	// SearchCompressed fetches matching tags based on a query.
	SearchCompressed(
		ctx context.Context,
		query *storage.FetchQuery,
		options *storage.FetchOptions,
	) (consolidators.TagResult, Cleanup, error)

	// CompleteTagsCompressed returns autocompleted tag results.
	CompleteTagsCompressed(
		ctx context.Context,
		query *storage.CompleteTagsQuery,
		options *storage.FetchOptions,
	) (*consolidators.CompleteTagsResult, error)
}

type RateLimiter interface {
	// Limit returns a boolean indicating whether or not the storage write may proceed.
	Limit(context.Context, ClusterNamespace, queryts.Datapoints, []models.Tag) bool
	Close() error
}

type RetentionResolution struct {
	Retention  time.Duration
	Resolution time.Duration
}

type SeriesIteratorProcessor interface {
	// InspectSeries inspects SeriesIterator slices for a given query.
	InspectSeries(
		ctx context.Context,
		query index.Query,
		queryOpts index.QueryOptions,
		seriesIterators []encoding.SeriesIterator,
	) error
}

type Storage interface {
	storage.Storage
	Querier
}

type TagsTransform func(context.Context, ClusterNamespace, []models.Tag) ([]models.Tag, error)

type UnaggregatedClusterNamespaceDefinition struct {
	NamespaceID ident.ID
	Session     client.Session
	Retention   time.Duration
}