Documentation

Overview

    Package runtime is a generated GoMock package.

    Index

    Constants

    View Source
    const (
    	// DefaultWriteConsistencyLevel is the default write consistency level
    	DefaultWriteConsistencyLevel = topology.ConsistencyLevelMajority
    
    	// DefaultReadConsistencyLevel is the default read consistency level
    	DefaultReadConsistencyLevel = topology.ReadConsistencyLevelUnstrictMajority
    
    	// DefaultBootstrapConsistencyLevel is the default bootstrap consistency level
    	DefaultBootstrapConsistencyLevel = topology.ReadConsistencyLevelMajority
    
    	// DefaultIndexDefaultQueryTimeout is the hard timeout value to use if none is
    	// specified for a specific query, zero specifies no timeout.
    	DefaultIndexDefaultQueryTimeout = time.Minute
    )

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type MockOptions

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

      MockOptions is a mock of Options interface

      func NewMockOptions

      func NewMockOptions(ctrl *gomock.Controller) *MockOptions

        NewMockOptions creates a new mock instance

        func (*MockOptions) ClientBootstrapConsistencyLevel

        func (m *MockOptions) ClientBootstrapConsistencyLevel() topology.ReadConsistencyLevel

          ClientBootstrapConsistencyLevel mocks base method

          func (*MockOptions) ClientReadConsistencyLevel

          func (m *MockOptions) ClientReadConsistencyLevel() topology.ReadConsistencyLevel

            ClientReadConsistencyLevel mocks base method

            func (*MockOptions) ClientWriteConsistencyLevel

            func (m *MockOptions) ClientWriteConsistencyLevel() topology.ConsistencyLevel

              ClientWriteConsistencyLevel mocks base method

              func (*MockOptions) EXPECT

              func (m *MockOptions) EXPECT() *MockOptionsMockRecorder

                EXPECT returns an object that allows the caller to indicate expected use

                func (*MockOptions) EncodersPerBlockLimit

                func (m *MockOptions) EncodersPerBlockLimit() int

                  EncodersPerBlockLimit mocks base method

                  func (*MockOptions) IndexDefaultQueryTimeout

                  func (m *MockOptions) IndexDefaultQueryTimeout() time.Duration

                    IndexDefaultQueryTimeout mocks base method

                    func (*MockOptions) MaxWiredBlocks

                    func (m *MockOptions) MaxWiredBlocks() uint

                      MaxWiredBlocks mocks base method

                      func (*MockOptions) PersistRateLimitOptions

                      func (m *MockOptions) PersistRateLimitOptions() ratelimit.Options

                        PersistRateLimitOptions mocks base method

                        func (*MockOptions) SetClientBootstrapConsistencyLevel

                        func (m *MockOptions) SetClientBootstrapConsistencyLevel(value topology.ReadConsistencyLevel) Options

                          SetClientBootstrapConsistencyLevel mocks base method

                          func (*MockOptions) SetClientReadConsistencyLevel

                          func (m *MockOptions) SetClientReadConsistencyLevel(value topology.ReadConsistencyLevel) Options

                            SetClientReadConsistencyLevel mocks base method

                            func (*MockOptions) SetClientWriteConsistencyLevel

                            func (m *MockOptions) SetClientWriteConsistencyLevel(value topology.ConsistencyLevel) Options

                              SetClientWriteConsistencyLevel mocks base method

                              func (*MockOptions) SetEncodersPerBlockLimit

                              func (m *MockOptions) SetEncodersPerBlockLimit(value int) Options

                                SetEncodersPerBlockLimit mocks base method

                                func (*MockOptions) SetIndexDefaultQueryTimeout

                                func (m *MockOptions) SetIndexDefaultQueryTimeout(value time.Duration) Options

                                  SetIndexDefaultQueryTimeout mocks base method

                                  func (*MockOptions) SetMaxWiredBlocks

                                  func (m *MockOptions) SetMaxWiredBlocks(value uint) Options

                                    SetMaxWiredBlocks mocks base method

                                    func (*MockOptions) SetPersistRateLimitOptions

                                    func (m *MockOptions) SetPersistRateLimitOptions(value ratelimit.Options) Options

                                      SetPersistRateLimitOptions mocks base method

                                      func (*MockOptions) SetTickMinimumInterval

                                      func (m *MockOptions) SetTickMinimumInterval(value time.Duration) Options

                                        SetTickMinimumInterval mocks base method

                                        func (*MockOptions) SetTickPerSeriesSleepDuration

                                        func (m *MockOptions) SetTickPerSeriesSleepDuration(value time.Duration) Options

                                          SetTickPerSeriesSleepDuration mocks base method

                                          func (*MockOptions) SetTickSeriesBatchSize

                                          func (m *MockOptions) SetTickSeriesBatchSize(value int) Options

                                            SetTickSeriesBatchSize mocks base method

                                            func (*MockOptions) SetWriteNewSeriesAsync

                                            func (m *MockOptions) SetWriteNewSeriesAsync(value bool) Options

                                              SetWriteNewSeriesAsync mocks base method

                                              func (*MockOptions) SetWriteNewSeriesBackoffDuration

                                              func (m *MockOptions) SetWriteNewSeriesBackoffDuration(value time.Duration) Options

                                                SetWriteNewSeriesBackoffDuration mocks base method

                                                func (*MockOptions) SetWriteNewSeriesLimitPerShardPerSecond

                                                func (m *MockOptions) SetWriteNewSeriesLimitPerShardPerSecond(value int) Options

                                                  SetWriteNewSeriesLimitPerShardPerSecond mocks base method

                                                  func (*MockOptions) TickMinimumInterval

                                                  func (m *MockOptions) TickMinimumInterval() time.Duration

                                                    TickMinimumInterval mocks base method

                                                    func (*MockOptions) TickPerSeriesSleepDuration

                                                    func (m *MockOptions) TickPerSeriesSleepDuration() time.Duration

                                                      TickPerSeriesSleepDuration mocks base method

                                                      func (*MockOptions) TickSeriesBatchSize

                                                      func (m *MockOptions) TickSeriesBatchSize() int

                                                        TickSeriesBatchSize mocks base method

                                                        func (*MockOptions) Validate

                                                        func (m *MockOptions) Validate() error

                                                          Validate mocks base method

                                                          func (*MockOptions) WriteNewSeriesAsync

                                                          func (m *MockOptions) WriteNewSeriesAsync() bool

                                                            WriteNewSeriesAsync mocks base method

                                                            func (*MockOptions) WriteNewSeriesBackoffDuration

                                                            func (m *MockOptions) WriteNewSeriesBackoffDuration() time.Duration

                                                              WriteNewSeriesBackoffDuration mocks base method

                                                              func (*MockOptions) WriteNewSeriesLimitPerShardPerSecond

                                                              func (m *MockOptions) WriteNewSeriesLimitPerShardPerSecond() int

                                                                WriteNewSeriesLimitPerShardPerSecond mocks base method

                                                                type MockOptionsListener

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

                                                                  MockOptionsListener is a mock of OptionsListener interface

                                                                  func NewMockOptionsListener

                                                                  func NewMockOptionsListener(ctrl *gomock.Controller) *MockOptionsListener

                                                                    NewMockOptionsListener creates a new mock instance

                                                                    func (*MockOptionsListener) EXPECT

                                                                      EXPECT returns an object that allows the caller to indicate expected use

                                                                      func (*MockOptionsListener) SetRuntimeOptions

                                                                      func (m *MockOptionsListener) SetRuntimeOptions(value Options)

                                                                        SetRuntimeOptions mocks base method

                                                                        type MockOptionsListenerMockRecorder

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

                                                                          MockOptionsListenerMockRecorder is the mock recorder for MockOptionsListener

                                                                          func (*MockOptionsListenerMockRecorder) SetRuntimeOptions

                                                                          func (mr *MockOptionsListenerMockRecorder) SetRuntimeOptions(value interface{}) *gomock.Call

                                                                            SetRuntimeOptions indicates an expected call of SetRuntimeOptions

                                                                            type MockOptionsManager

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

                                                                              MockOptionsManager is a mock of OptionsManager interface

                                                                              func NewMockOptionsManager

                                                                              func NewMockOptionsManager(ctrl *gomock.Controller) *MockOptionsManager

                                                                                NewMockOptionsManager creates a new mock instance

                                                                                func (*MockOptionsManager) Close

                                                                                func (m *MockOptionsManager) Close()

                                                                                  Close mocks base method

                                                                                  func (*MockOptionsManager) EXPECT

                                                                                    EXPECT returns an object that allows the caller to indicate expected use

                                                                                    func (*MockOptionsManager) Get

                                                                                    func (m *MockOptionsManager) Get() Options

                                                                                      Get mocks base method

                                                                                      func (*MockOptionsManager) RegisterListener

                                                                                        RegisterListener mocks base method

                                                                                        func (*MockOptionsManager) Update

                                                                                        func (m *MockOptionsManager) Update(value Options) error

                                                                                          Update mocks base method

                                                                                          type MockOptionsManagerMockRecorder

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

                                                                                            MockOptionsManagerMockRecorder is the mock recorder for MockOptionsManager

                                                                                            func (*MockOptionsManagerMockRecorder) Close

                                                                                              Close indicates an expected call of Close

                                                                                              func (*MockOptionsManagerMockRecorder) Get

                                                                                                Get indicates an expected call of Get

                                                                                                func (*MockOptionsManagerMockRecorder) RegisterListener

                                                                                                func (mr *MockOptionsManagerMockRecorder) RegisterListener(l interface{}) *gomock.Call

                                                                                                  RegisterListener indicates an expected call of RegisterListener

                                                                                                  func (*MockOptionsManagerMockRecorder) Update

                                                                                                  func (mr *MockOptionsManagerMockRecorder) Update(value interface{}) *gomock.Call

                                                                                                    Update indicates an expected call of Update

                                                                                                    type MockOptionsMockRecorder

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

                                                                                                      MockOptionsMockRecorder is the mock recorder for MockOptions

                                                                                                      func (*MockOptionsMockRecorder) ClientBootstrapConsistencyLevel

                                                                                                      func (mr *MockOptionsMockRecorder) ClientBootstrapConsistencyLevel() *gomock.Call

                                                                                                        ClientBootstrapConsistencyLevel indicates an expected call of ClientBootstrapConsistencyLevel

                                                                                                        func (*MockOptionsMockRecorder) ClientReadConsistencyLevel

                                                                                                        func (mr *MockOptionsMockRecorder) ClientReadConsistencyLevel() *gomock.Call

                                                                                                          ClientReadConsistencyLevel indicates an expected call of ClientReadConsistencyLevel

                                                                                                          func (*MockOptionsMockRecorder) ClientWriteConsistencyLevel

                                                                                                          func (mr *MockOptionsMockRecorder) ClientWriteConsistencyLevel() *gomock.Call

                                                                                                            ClientWriteConsistencyLevel indicates an expected call of ClientWriteConsistencyLevel

                                                                                                            func (*MockOptionsMockRecorder) EncodersPerBlockLimit

                                                                                                            func (mr *MockOptionsMockRecorder) EncodersPerBlockLimit() *gomock.Call

                                                                                                              EncodersPerBlockLimit indicates an expected call of EncodersPerBlockLimit

                                                                                                              func (*MockOptionsMockRecorder) IndexDefaultQueryTimeout

                                                                                                              func (mr *MockOptionsMockRecorder) IndexDefaultQueryTimeout() *gomock.Call

                                                                                                                IndexDefaultQueryTimeout indicates an expected call of IndexDefaultQueryTimeout

                                                                                                                func (*MockOptionsMockRecorder) MaxWiredBlocks

                                                                                                                func (mr *MockOptionsMockRecorder) MaxWiredBlocks() *gomock.Call

                                                                                                                  MaxWiredBlocks indicates an expected call of MaxWiredBlocks

                                                                                                                  func (*MockOptionsMockRecorder) PersistRateLimitOptions

                                                                                                                  func (mr *MockOptionsMockRecorder) PersistRateLimitOptions() *gomock.Call

                                                                                                                    PersistRateLimitOptions indicates an expected call of PersistRateLimitOptions

                                                                                                                    func (*MockOptionsMockRecorder) SetClientBootstrapConsistencyLevel

                                                                                                                    func (mr *MockOptionsMockRecorder) SetClientBootstrapConsistencyLevel(value interface{}) *gomock.Call

                                                                                                                      SetClientBootstrapConsistencyLevel indicates an expected call of SetClientBootstrapConsistencyLevel

                                                                                                                      func (*MockOptionsMockRecorder) SetClientReadConsistencyLevel

                                                                                                                      func (mr *MockOptionsMockRecorder) SetClientReadConsistencyLevel(value interface{}) *gomock.Call

                                                                                                                        SetClientReadConsistencyLevel indicates an expected call of SetClientReadConsistencyLevel

                                                                                                                        func (*MockOptionsMockRecorder) SetClientWriteConsistencyLevel

                                                                                                                        func (mr *MockOptionsMockRecorder) SetClientWriteConsistencyLevel(value interface{}) *gomock.Call

                                                                                                                          SetClientWriteConsistencyLevel indicates an expected call of SetClientWriteConsistencyLevel

                                                                                                                          func (*MockOptionsMockRecorder) SetEncodersPerBlockLimit

                                                                                                                          func (mr *MockOptionsMockRecorder) SetEncodersPerBlockLimit(value interface{}) *gomock.Call

                                                                                                                            SetEncodersPerBlockLimit indicates an expected call of SetEncodersPerBlockLimit

                                                                                                                            func (*MockOptionsMockRecorder) SetIndexDefaultQueryTimeout

                                                                                                                            func (mr *MockOptionsMockRecorder) SetIndexDefaultQueryTimeout(value interface{}) *gomock.Call

                                                                                                                              SetIndexDefaultQueryTimeout indicates an expected call of SetIndexDefaultQueryTimeout

                                                                                                                              func (*MockOptionsMockRecorder) SetMaxWiredBlocks

                                                                                                                              func (mr *MockOptionsMockRecorder) SetMaxWiredBlocks(value interface{}) *gomock.Call

                                                                                                                                SetMaxWiredBlocks indicates an expected call of SetMaxWiredBlocks

                                                                                                                                func (*MockOptionsMockRecorder) SetPersistRateLimitOptions

                                                                                                                                func (mr *MockOptionsMockRecorder) SetPersistRateLimitOptions(value interface{}) *gomock.Call

                                                                                                                                  SetPersistRateLimitOptions indicates an expected call of SetPersistRateLimitOptions

                                                                                                                                  func (*MockOptionsMockRecorder) SetTickMinimumInterval

                                                                                                                                  func (mr *MockOptionsMockRecorder) SetTickMinimumInterval(value interface{}) *gomock.Call

                                                                                                                                    SetTickMinimumInterval indicates an expected call of SetTickMinimumInterval

                                                                                                                                    func (*MockOptionsMockRecorder) SetTickPerSeriesSleepDuration

                                                                                                                                    func (mr *MockOptionsMockRecorder) SetTickPerSeriesSleepDuration(value interface{}) *gomock.Call

                                                                                                                                      SetTickPerSeriesSleepDuration indicates an expected call of SetTickPerSeriesSleepDuration

                                                                                                                                      func (*MockOptionsMockRecorder) SetTickSeriesBatchSize

                                                                                                                                      func (mr *MockOptionsMockRecorder) SetTickSeriesBatchSize(value interface{}) *gomock.Call

                                                                                                                                        SetTickSeriesBatchSize indicates an expected call of SetTickSeriesBatchSize

                                                                                                                                        func (*MockOptionsMockRecorder) SetWriteNewSeriesAsync

                                                                                                                                        func (mr *MockOptionsMockRecorder) SetWriteNewSeriesAsync(value interface{}) *gomock.Call

                                                                                                                                          SetWriteNewSeriesAsync indicates an expected call of SetWriteNewSeriesAsync

                                                                                                                                          func (*MockOptionsMockRecorder) SetWriteNewSeriesBackoffDuration

                                                                                                                                          func (mr *MockOptionsMockRecorder) SetWriteNewSeriesBackoffDuration(value interface{}) *gomock.Call

                                                                                                                                            SetWriteNewSeriesBackoffDuration indicates an expected call of SetWriteNewSeriesBackoffDuration

                                                                                                                                            func (*MockOptionsMockRecorder) SetWriteNewSeriesLimitPerShardPerSecond

                                                                                                                                            func (mr *MockOptionsMockRecorder) SetWriteNewSeriesLimitPerShardPerSecond(value interface{}) *gomock.Call

                                                                                                                                              SetWriteNewSeriesLimitPerShardPerSecond indicates an expected call of SetWriteNewSeriesLimitPerShardPerSecond

                                                                                                                                              func (*MockOptionsMockRecorder) TickMinimumInterval

                                                                                                                                              func (mr *MockOptionsMockRecorder) TickMinimumInterval() *gomock.Call

                                                                                                                                                TickMinimumInterval indicates an expected call of TickMinimumInterval

                                                                                                                                                func (*MockOptionsMockRecorder) TickPerSeriesSleepDuration

                                                                                                                                                func (mr *MockOptionsMockRecorder) TickPerSeriesSleepDuration() *gomock.Call

                                                                                                                                                  TickPerSeriesSleepDuration indicates an expected call of TickPerSeriesSleepDuration

                                                                                                                                                  func (*MockOptionsMockRecorder) TickSeriesBatchSize

                                                                                                                                                  func (mr *MockOptionsMockRecorder) TickSeriesBatchSize() *gomock.Call

                                                                                                                                                    TickSeriesBatchSize indicates an expected call of TickSeriesBatchSize

                                                                                                                                                    func (*MockOptionsMockRecorder) Validate

                                                                                                                                                    func (mr *MockOptionsMockRecorder) Validate() *gomock.Call

                                                                                                                                                      Validate indicates an expected call of Validate

                                                                                                                                                      func (*MockOptionsMockRecorder) WriteNewSeriesAsync

                                                                                                                                                      func (mr *MockOptionsMockRecorder) WriteNewSeriesAsync() *gomock.Call

                                                                                                                                                        WriteNewSeriesAsync indicates an expected call of WriteNewSeriesAsync

                                                                                                                                                        func (*MockOptionsMockRecorder) WriteNewSeriesBackoffDuration

                                                                                                                                                        func (mr *MockOptionsMockRecorder) WriteNewSeriesBackoffDuration() *gomock.Call

                                                                                                                                                          WriteNewSeriesBackoffDuration indicates an expected call of WriteNewSeriesBackoffDuration

                                                                                                                                                          func (*MockOptionsMockRecorder) WriteNewSeriesLimitPerShardPerSecond

                                                                                                                                                          func (mr *MockOptionsMockRecorder) WriteNewSeriesLimitPerShardPerSecond() *gomock.Call

                                                                                                                                                            WriteNewSeriesLimitPerShardPerSecond indicates an expected call of WriteNewSeriesLimitPerShardPerSecond

                                                                                                                                                            type Options

                                                                                                                                                            type Options interface {
                                                                                                                                                            	// Validate will validate the runtime options are valid.
                                                                                                                                                            	Validate() error
                                                                                                                                                            
                                                                                                                                                            	// SetPersistRateLimitOptions sets the persist rate limit options
                                                                                                                                                            	SetPersistRateLimitOptions(value ratelimit.Options) Options
                                                                                                                                                            
                                                                                                                                                            	// PersistRateLimitOptions returns the persist rate limit options
                                                                                                                                                            	PersistRateLimitOptions() ratelimit.Options
                                                                                                                                                            
                                                                                                                                                            	// SetWriteNewSeriesAsync sets whether to write new series asynchronously or not,
                                                                                                                                                            	// when true this essentially makes writes for new series eventually consistent
                                                                                                                                                            	// as after a write is finished you are not guaranteed to read it back immediately
                                                                                                                                                            	// due to inserts into the shard map being buffered. The write is however written
                                                                                                                                                            	// to the commit log before completing so it is considered durable.
                                                                                                                                                            	SetWriteNewSeriesAsync(value bool) Options
                                                                                                                                                            
                                                                                                                                                            	// WriteNewSeriesAsync returns whether to write new series asynchronously or not,
                                                                                                                                                            	// when true this essentially makes writes for new series eventually consistent
                                                                                                                                                            	// as after a write is finished you are not guaranteed to read it back immediately
                                                                                                                                                            	// due to inserts into the shard map being buffered. The write is however written
                                                                                                                                                            	// to the commit log before completing so it is considered durable.
                                                                                                                                                            	WriteNewSeriesAsync() bool
                                                                                                                                                            
                                                                                                                                                            	// SetWriteNewSeriesBackoffDuration sets the insert backoff duration during
                                                                                                                                                            	// periods of heavy insertions, this backoff helps gather larger batches
                                                                                                                                                            	// to insert into a shard in a single batch requiring far less write lock
                                                                                                                                                            	// acquisitions.
                                                                                                                                                            	SetWriteNewSeriesBackoffDuration(value time.Duration) Options
                                                                                                                                                            
                                                                                                                                                            	// WriteNewSeriesBackoffDuration returns the insert backoff duration during
                                                                                                                                                            	// periods of heavy insertions, this backoff helps gather larger batches
                                                                                                                                                            	// to insert into a shard in a single batch requiring far less write lock
                                                                                                                                                            	// acquisitions.
                                                                                                                                                            	WriteNewSeriesBackoffDuration() time.Duration
                                                                                                                                                            
                                                                                                                                                            	// SetWriteNewSeriesLimitPerShardPerSecond sets the insert rate limit per second,
                                                                                                                                                            	// setting to zero disables any rate limit for new series insertions. This rate
                                                                                                                                                            	// limit is primarily offered to defend against unintentional bursts of new
                                                                                                                                                            	// time series being inserted.
                                                                                                                                                            	SetWriteNewSeriesLimitPerShardPerSecond(value int) Options
                                                                                                                                                            
                                                                                                                                                            	// WriteNewSeriesLimitPerShardPerSecond returns the insert rate limit per second,
                                                                                                                                                            	// setting to zero disables any rate limit for new series insertions. This rate
                                                                                                                                                            	// limit is primarily offered to defend against unintentional bursts of new
                                                                                                                                                            	// time series being inserted.
                                                                                                                                                            	WriteNewSeriesLimitPerShardPerSecond() int
                                                                                                                                                            
                                                                                                                                                            	// SetEncodersPerBlockLimit sets the maximum number of encoders per block
                                                                                                                                                            	// allowed. Setting to zero means an unlimited number of encoders are
                                                                                                                                                            	// permitted. This rate limit is primarily offered to defend against
                                                                                                                                                            	// bursts of out of order writes, which creates many encoders, subsequently
                                                                                                                                                            	// causing a large burst in CPU load when trying to merge them.
                                                                                                                                                            	SetEncodersPerBlockLimit(value int) Options
                                                                                                                                                            
                                                                                                                                                            	// EncodersPerBlockLimit sets the maximum number of encoders per block
                                                                                                                                                            	// allowed. Setting to zero means an unlimited number of encoders are
                                                                                                                                                            	// permitted. This rate limit is primarily offered to defend against
                                                                                                                                                            	// bursts of out of order writes, which creates many encoders, subsequently
                                                                                                                                                            	// causing a large burst in CPU load when trying to merge them.
                                                                                                                                                            	EncodersPerBlockLimit() int
                                                                                                                                                            
                                                                                                                                                            	// SetTickSeriesBatchSize sets the batch size to process series together
                                                                                                                                                            	// during a tick before yielding and sleeping the per series duration
                                                                                                                                                            	// multiplied by the batch size.
                                                                                                                                                            	// The higher this value is the more variable CPU utilization will be
                                                                                                                                                            	// but the shorter ticks will ultimately be.
                                                                                                                                                            	SetTickSeriesBatchSize(value int) Options
                                                                                                                                                            
                                                                                                                                                            	// TickSeriesBatchSize returns the batch size to process series together
                                                                                                                                                            	// during a tick before yielding and sleeping the per series duration
                                                                                                                                                            	// multiplied by the batch size.
                                                                                                                                                            	// The higher this value is the more variable CPU utilization will be
                                                                                                                                                            	// but the shorter ticks will ultimately be.
                                                                                                                                                            	TickSeriesBatchSize() int
                                                                                                                                                            
                                                                                                                                                            	// SetTickPerSeriesSleepDuration sets the tick sleep per series value that
                                                                                                                                                            	// provides a constant duration to sleep per series at the end of processing
                                                                                                                                                            	// a batch of series during a background tick, this can directly effect how
                                                                                                                                                            	// fast a block is persisted after is rotated from the mutable series buffer
                                                                                                                                                            	// to a series block (since all series need to be merged/processed before a
                                                                                                                                                            	// persist can occur).
                                                                                                                                                            	SetTickPerSeriesSleepDuration(value time.Duration) Options
                                                                                                                                                            
                                                                                                                                                            	// TickPerSeriesSleepDuration returns the tick sleep per series value that
                                                                                                                                                            	// provides a constant duration to sleep per series at the end of processing
                                                                                                                                                            	// a batch of series during a background tick, this can directly effect how
                                                                                                                                                            	// fast a block is persisted after is rotated from the mutable series buffer
                                                                                                                                                            	// to a series block (since all series need to be merged/processed before a
                                                                                                                                                            	// persist can occur).
                                                                                                                                                            	TickPerSeriesSleepDuration() time.Duration
                                                                                                                                                            
                                                                                                                                                            	// SetTickMinimumInterval sets the minimum tick interval to run ticks, this
                                                                                                                                                            	// helps throttle the tick when the amount of series is low and the sleeps
                                                                                                                                                            	// on a per series basis is short.
                                                                                                                                                            	SetTickMinimumInterval(value time.Duration) Options
                                                                                                                                                            
                                                                                                                                                            	// TickMinimumInterval returns the minimum tick interval to run ticks, this
                                                                                                                                                            	// helps throttle the tick when the amount of series is low and the sleeps
                                                                                                                                                            	// on a per series basis is short.
                                                                                                                                                            	TickMinimumInterval() time.Duration
                                                                                                                                                            
                                                                                                                                                            	// SetMaxWiredBlocks sets the max blocks to keep wired; zero is used
                                                                                                                                                            	// to specify no limit. Wired blocks that are in the buffer, I.E are
                                                                                                                                                            	// being written to, cannot be unwired. Similarly, blocks which have
                                                                                                                                                            	// just been rotated out of the buffer but have not been flushed yet
                                                                                                                                                            	// can also not be unwired. This means that the limit is best effort.
                                                                                                                                                            	SetMaxWiredBlocks(value uint) Options
                                                                                                                                                            
                                                                                                                                                            	// MaxWiredBlocks returns the max blocks to keep wired, zero is used
                                                                                                                                                            	// to specify no limit. Wired blocks that are in the buffer, I.E are
                                                                                                                                                            	// being written to, cannot be unwired. Similarly, blocks which have
                                                                                                                                                            	// just been rotated out of the buffer but have not been flushed yet
                                                                                                                                                            	// can also not be unwired. This means that the limit is best effort.
                                                                                                                                                            	MaxWiredBlocks() uint
                                                                                                                                                            
                                                                                                                                                            	// SetClientBootstrapConsistencyLevel sets the client bootstrap
                                                                                                                                                            	// consistency level used when bootstrapping from peers. Setting this
                                                                                                                                                            	// will take effect immediately, and as such can be used to finish a
                                                                                                                                                            	// bootstrap in an unhealthy cluster to recover read capability by setting
                                                                                                                                                            	// this value to ReadConsistencyLevelNone.
                                                                                                                                                            	SetClientBootstrapConsistencyLevel(value topology.ReadConsistencyLevel) Options
                                                                                                                                                            
                                                                                                                                                            	// ClientBootstrapConsistencyLevel returns the client bootstrap
                                                                                                                                                            	// consistency level used when bootstrapping from peers. Setting this
                                                                                                                                                            	// will take effect immediately, and as such can be used to finish a
                                                                                                                                                            	// bootstrap in an unhealthy cluster to recover read capability by setting
                                                                                                                                                            	// this value to ReadConsistencyLevelNone.
                                                                                                                                                            	ClientBootstrapConsistencyLevel() topology.ReadConsistencyLevel
                                                                                                                                                            
                                                                                                                                                            	// SetClientReadConsistencyLevel sets the client read consistency level
                                                                                                                                                            	// used when fetching data from peers for coordinated reads
                                                                                                                                                            	SetClientReadConsistencyLevel(value topology.ReadConsistencyLevel) Options
                                                                                                                                                            
                                                                                                                                                            	// ClientReadConsistencyLevel returns the client read consistency level
                                                                                                                                                            	// used when fetching data from peers for coordinated reads
                                                                                                                                                            	ClientReadConsistencyLevel() topology.ReadConsistencyLevel
                                                                                                                                                            
                                                                                                                                                            	// SetClientWriteConsistencyLevel sets the client write consistency level
                                                                                                                                                            	// used when fetching data from peers for coordinated writes
                                                                                                                                                            	SetClientWriteConsistencyLevel(value topology.ConsistencyLevel) Options
                                                                                                                                                            
                                                                                                                                                            	// ClientWriteConsistencyLevel returns the client write consistency level
                                                                                                                                                            	// used when fetching data from peers for coordinated writes
                                                                                                                                                            	ClientWriteConsistencyLevel() topology.ConsistencyLevel
                                                                                                                                                            
                                                                                                                                                            	// SetIndexDefaultQueryTimeout is the hard timeout value to use if none is
                                                                                                                                                            	// specified for a specific query, zero specifies to use no timeout at all.
                                                                                                                                                            	SetIndexDefaultQueryTimeout(value time.Duration) Options
                                                                                                                                                            
                                                                                                                                                            	// IndexDefaultQueryTimeout is the hard timeout value to use if none is
                                                                                                                                                            	// specified for a specific query, zero specifies to use no timeout at all.
                                                                                                                                                            	IndexDefaultQueryTimeout() time.Duration
                                                                                                                                                            }

                                                                                                                                                              Options is a set of runtime options.

                                                                                                                                                              func NewOptions

                                                                                                                                                              func NewOptions() Options

                                                                                                                                                                NewOptions creates a new set of runtime options with defaults

                                                                                                                                                                type OptionsListener

                                                                                                                                                                type OptionsListener interface {
                                                                                                                                                                	// SetRuntimeOptions is called when the listener is registered
                                                                                                                                                                	// and when any updates occurred passing the new runtime options.
                                                                                                                                                                	SetRuntimeOptions(value Options)
                                                                                                                                                                }

                                                                                                                                                                  OptionsListener listens for updates to runtime options.

                                                                                                                                                                  type OptionsManager

                                                                                                                                                                  type OptionsManager interface {
                                                                                                                                                                  	// Update updates the current runtime options.
                                                                                                                                                                  	Update(value Options) error
                                                                                                                                                                  
                                                                                                                                                                  	// Get returns the current values.
                                                                                                                                                                  	Get() Options
                                                                                                                                                                  
                                                                                                                                                                  	// RegisterListener registers a listener for updates to runtime options,
                                                                                                                                                                  	// it will synchronously call back the listener when this method is called
                                                                                                                                                                  	// to deliver the current set of runtime options.
                                                                                                                                                                  	RegisterListener(l OptionsListener) xresource.SimpleCloser
                                                                                                                                                                  
                                                                                                                                                                  	// Close closes the watcher and all descendent watches.
                                                                                                                                                                  	Close()
                                                                                                                                                                  }

                                                                                                                                                                    OptionsManager updates and supplies runtime options.

                                                                                                                                                                    func NewNoOpOptionsManager

                                                                                                                                                                    func NewNoOpOptionsManager(opts Options) OptionsManager

                                                                                                                                                                      NewNoOpOptionsManager returns a no-op options manager that cannot be updated and does not spawn backround goroutines (useful for globals in test files).

                                                                                                                                                                      func NewOptionsManager

                                                                                                                                                                      func NewOptionsManager() OptionsManager

                                                                                                                                                                        NewOptionsManager creates a new runtime options manager