Documentation

Overview

    Package namespace is a generated GoMock package.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func AppendSchemaOptions

    func AppendSchemaOptions(schemaOpt *nsproto.SchemaOptions, protoFile, msgName string, contents map[string]string, deployID string) (*nsproto.SchemaOptions, error)

      AppendSchemaOptions appends to a provided SchemaOptions with a new version of schema. The new version of schema is parsed out of the provided protoFile/msgName/contents. schemaOpt: the SchemaOptions to be appended to, if nil, a new SchemaOption is created. deployID: the version ID of the new schema. protoFile: name of the top level proto file. msgName: name of the top level proto message. contents: map of name to proto strings.

      Except for the top level proto file, other imported proto files' key must be exactly the same
      as how they are imported in the import statement:
      E.g. if import.proto is imported as below
      import "mainpkg/imported.proto";
      Then the map key for improted.proto must be "mainpkg/imported.proto"
      See src/dbnode/namesapce/kvadmin test for example.
      

      func FromNanos

      func FromNanos(n int64) time.Duration

        FromNanos converts nanoseconds to a namespace-compatible duration.

        func GenTestSchemaOptions

        func GenTestSchemaOptions(protoFile string, importPath ...string) *nsproto.SchemaOptions

        func LoadSchemaRegistryFromFile

        func LoadSchemaRegistryFromFile(schemaReg SchemaRegistry, nsID ident.ID, deployID string, protoFile string, msgName string, importPath ...string) error

        func OptionsToProto

        func OptionsToProto(opts Options) (*nsproto.NamespaceOptions, error)

          OptionsToProto converts Options -> nsproto.NamespaceOptions

          func RegisterExtendedOptionsConverter

          func RegisterExtendedOptionsConverter(typeURLPrefix string, msg proto.Message, converter ExtendedOptsConverter)

            RegisterExtendedOptionsConverter registers conversion function from protobuf message to ExtendedOptions.

            func ToProto

            func ToProto(m Map) (*nsproto.Registry, error)

              ToProto converts Map to nsproto.Registry

              func ToRetention

              func ToRetention(
              	ro *nsproto.RetentionOptions,
              ) (retention.Options, error)

                ToRetention converts nsproto.RetentionOptions to retention.Options

                func UpdateSchemaRegistry

                func UpdateSchemaRegistry(newNamespaces Map, schemaReg SchemaRegistry, log *zap.Logger) error

                  UpdateSchemaRegistry updates schema registry with namespace updates.

                  Types

                  type AggregatedAttributes

                  type AggregatedAttributes struct {
                  	// Resolution is the time range to aggregate data across.
                  	Resolution time.Duration
                  
                  	// DownsampleOptions stores options around how data points are downsampled.
                  	DownsampleOptions DownsampleOptions
                  }

                    AggregationAttributes are attributes specifying how data points should be aggregated.

                    func NewAggregatedAttributes

                    func NewAggregatedAttributes(resolution time.Duration, downsampleOptions DownsampleOptions) (AggregatedAttributes, error)

                      NewAggregateAttributes creates new AggregatedAttributes.

                      type Aggregation

                      type Aggregation struct {
                      	// Aggregated is true if data points are aggregated, false otherwise.
                      	Aggregated bool
                      
                      	// Attributes specifies how to aggregate data when aggregated is set to true.
                      	// This field is ignored when aggregated is false.
                      	Attributes AggregatedAttributes
                      }

                        Aggregation describes data points within the namespace.

                        func NewAggregatedAggregation

                        func NewAggregatedAggregation(attrs AggregatedAttributes) Aggregation

                          NewAggregatedAggregation creates a new aggregated Aggregation.

                          func NewUnaggregatedAggregation

                          func NewUnaggregatedAggregation() Aggregation

                            NewUnaggregatedAggregation creates a new unaggregated Aggregation.

                            type AggregationOptions

                            type AggregationOptions interface {
                            	// Equal returns true if the provided value is equal to this one.
                            	Equal(value AggregationOptions) bool
                            
                            	// SetAggregations sets the aggregations for this namespace.
                            	SetAggregations(value []Aggregation) AggregationOptions
                            
                            	// Aggregations returns the aggregations for this namespace.
                            	Aggregations() []Aggregation
                            }

                              AggregationOptions is a set of options for aggregating data within the namespace.

                              func NewAggregationOptions

                              func NewAggregationOptions() AggregationOptions

                                NewAggregationOptions creates new AggregationOptions.

                                func ToAggregationOptions

                                func ToAggregationOptions(opts *nsproto.AggregationOptions) (AggregationOptions, error)

                                  ToAggregationOptions converts nsproto.AggregationOptions to AggregationOptions.

                                  type Context

                                  type Context struct {
                                  	ID     ident.ID
                                  	Schema SchemaDescr
                                  }

                                  func NewContextFor

                                  func NewContextFor(id ident.ID, registry SchemaRegistry) Context

                                  func NewContextFrom

                                  func NewContextFrom(nsMetadata Metadata) Context

                                  type DownsampleOptions

                                  type DownsampleOptions struct {
                                  	// All indicates whether to send data points to this namespace.
                                  	// If set to false, this namespace will not receive data points. In this
                                  	// case, data will need to be sent to the namespace via another mechanism
                                  	// (e.g. rollup/recording rules).
                                  	All bool
                                  }

                                    DownsampleOptions is a set of options related to downsampling data.

                                    func NewDownsampleOptions

                                    func NewDownsampleOptions(all bool) DownsampleOptions

                                      NewDownsampleOptions creates new DownsampleOptions.

                                      type DynamicOptions

                                      type DynamicOptions interface {
                                      	// Validate validates the options.
                                      	Validate() error
                                      
                                      	// SetInstrumentOptions sets the instrumentation options.
                                      	SetInstrumentOptions(value instrument.Options) DynamicOptions
                                      
                                      	// InstrumentOptions returns the instrumentation options.
                                      	InstrumentOptions() instrument.Options
                                      
                                      	// SetConfigServiceClient sets the client of ConfigService.
                                      	SetConfigServiceClient(c client.Client) DynamicOptions
                                      
                                      	// ConfigServiceClient returns the client of ConfigService.
                                      	ConfigServiceClient() client.Client
                                      
                                      	// SetNamespaceRegistryKey sets the kv-store key used for the NamespaceRegistry.
                                      	SetNamespaceRegistryKey(k string) DynamicOptions
                                      
                                      	// NamespaceRegistryKey returns the kv-store key used for the NamespaceRegistry.
                                      	NamespaceRegistryKey() string
                                      
                                      	// SetForceColdWritesEnabled sets whether or not to force enable cold writes
                                      	// for all ns.
                                      	SetForceColdWritesEnabled(enabled bool) DynamicOptions
                                      
                                      	// ForceColdWritesEnabled returns whether or not to force enable cold writes
                                      	// for all ns.
                                      	ForceColdWritesEnabled() bool
                                      
                                      	// SetAllowEmptyInitialNamespaceRegistry sets whether to allow the initial
                                      	// namespace update to be empty or to wait indefinitely until namespaces are received.
                                      	SetAllowEmptyInitialNamespaceRegistry(value bool) DynamicOptions
                                      
                                      	// AllowEmptyInitialNamespaceRegistry returns whether to allow the initial
                                      	// namespace update to be empty or to wait indefinitely until namespaces are received.
                                      	AllowEmptyInitialNamespaceRegistry() bool
                                      }

                                        DynamicOptions is a set of options for dynamic namespace registry.

                                        func NewDynamicOptions

                                        func NewDynamicOptions() DynamicOptions

                                          NewDynamicOptions creates a new DynamicOptions

                                          type ExtendedOptions

                                          type ExtendedOptions interface {
                                          	// ToProto converts ExtendedOptions to the corresponding protobuf message.
                                          	ToProto() (msg proto.Message, typeURLPrefix string)
                                          
                                          	// Validate validates the ExtendedOptions.
                                          	Validate() error
                                          }

                                            ExtendedOptions is the type for dynamically typed options.

                                            func ToExtendedOptions

                                            func ToExtendedOptions(
                                            	opts *protobuftypes.Any,
                                            ) (ExtendedOptions, error)

                                              ToExtendedOptions converts protobuf message to ExtendedOptions.

                                              type ExtendedOptsConverter

                                              type ExtendedOptsConverter func(proto.Message) (ExtendedOptions, error)

                                                ExtendedOptsConverter is function for converting from protobuf message to ExtendedOptions.

                                                type IndexConfiguration

                                                type IndexConfiguration struct {
                                                	Enabled   bool          `yaml:"enabled" validate:"nonzero"`
                                                	BlockSize time.Duration `yaml:"blockSize" validate:"nonzero"`
                                                }

                                                  IndexConfiguration controls the knobs to tweak indexing configuration.

                                                  func (*IndexConfiguration) Options

                                                  func (ic *IndexConfiguration) Options() IndexOptions

                                                    Options returns the IndexOptions corresponding to the receiver struct.

                                                    type IndexOptions

                                                    type IndexOptions interface {
                                                    	// Equal returns true if the provide value is equal to this one.
                                                    	Equal(value IndexOptions) bool
                                                    
                                                    	// SetEnabled sets whether indexing is enabled.
                                                    	SetEnabled(value bool) IndexOptions
                                                    
                                                    	// Enabled returns whether indexing is enabled.
                                                    	Enabled() bool
                                                    
                                                    	// SetBlockSize returns the block size.
                                                    	SetBlockSize(value time.Duration) IndexOptions
                                                    
                                                    	// BlockSize returns the block size.
                                                    	BlockSize() time.Duration
                                                    }

                                                      IndexOptions controls the indexing options for a namespace.

                                                      func NewIndexOptions

                                                      func NewIndexOptions() IndexOptions

                                                        NewIndexOptions returns a new IndexOptions.

                                                        func ToIndexOptions

                                                        func ToIndexOptions(
                                                        	io *nsproto.IndexOptions,
                                                        	defaultBlockSize time.Duration,
                                                        ) (IndexOptions, error)

                                                          ToIndexOptions converts nsproto.IndexOptions to IndexOptions

                                                          type Initializer

                                                          type Initializer interface {
                                                          	// Init will return a new Registry.
                                                          	Init() (Registry, error)
                                                          }

                                                            Initializer can init new instances of namespace registries.

                                                            func NewDynamicInitializer

                                                            func NewDynamicInitializer(opts DynamicOptions) Initializer

                                                              NewDynamicInitializer returns a dynamic namespace initializer

                                                              func NewStaticInitializer

                                                              func NewStaticInitializer(metadatas []Metadata) Initializer

                                                                NewStaticInitializer returns a new static registry initializer

                                                                type Map

                                                                type Map interface {
                                                                	// Equal returns true if the provide value is equal to this one.
                                                                	Equal(value Map) bool
                                                                
                                                                	// Get gets the metadata for the provided namespace.
                                                                	Get(ident.ID) (Metadata, error)
                                                                
                                                                	// IDs returns the ID of known namespaces.
                                                                	IDs() []ident.ID
                                                                
                                                                	// Metadatas returns the metadata of known namespaces.
                                                                	Metadatas() []Metadata
                                                                }

                                                                  Map is mapping from known namespaces' ID to their Metadata.

                                                                  func FromProto

                                                                  func FromProto(protoRegistry nsproto.Registry) (Map, error)

                                                                    FromProto converts nsproto.Registry -> Map

                                                                    func NewMap

                                                                    func NewMap(metadatas []Metadata) (Map, error)

                                                                      NewMap returns a new registry containing provided metadatas, providing a consistent order.

                                                                      type MapConfiguration

                                                                      type MapConfiguration struct {
                                                                      	Metadatas []MetadataConfiguration `yaml:"metadatas" validate:"nonzero"`
                                                                      }

                                                                        MapConfiguration is the configuration for a registry of namespaces

                                                                        func (*MapConfiguration) Map

                                                                        func (m *MapConfiguration) Map() (Map, error)

                                                                          Map returns a Map corresponding to the receiver struct

                                                                          type MessageDescriptor

                                                                          type MessageDescriptor struct {
                                                                          	*desc.MessageDescriptor
                                                                          }

                                                                          type Metadata

                                                                          type Metadata interface {
                                                                          	// Equal returns true if the provided value is equal to this one.
                                                                          	Equal(value Metadata) bool
                                                                          
                                                                          	// ID is the ID of the namespace.
                                                                          	ID() ident.ID
                                                                          
                                                                          	// Options is the namespace options.
                                                                          	Options() Options
                                                                          }

                                                                            Metadata represents namespace metadata information.

                                                                            func ForceColdWritesEnabledForMetadatas

                                                                            func ForceColdWritesEnabledForMetadatas(metadatas []Metadata) []Metadata

                                                                              ForceColdWritesEnabledForMetadatas forces cold writes to be enabled for all ns.

                                                                              func MustBuildMetadatas

                                                                              func MustBuildMetadatas(indexEnabled bool, ids ...string) []Metadata

                                                                                MustBuildMetadatas builds a list of metadatas for testing with given index enabled option and ids.

                                                                                func NewMetadata

                                                                                func NewMetadata(id ident.ID, opts Options) (Metadata, error)

                                                                                  NewMetadata creates a new namespace metadata

                                                                                  func ToMetadata

                                                                                  func ToMetadata(
                                                                                  	id string,
                                                                                  	opts *nsproto.NamespaceOptions,
                                                                                  ) (Metadata, error)

                                                                                    ToMetadata converts nsproto.Options to Metadata

                                                                                    type MetadataConfiguration

                                                                                    type MetadataConfiguration struct {
                                                                                    	ID                    string                  `yaml:"id" validate:"nonzero"`
                                                                                    	BootstrapEnabled      *bool                   `yaml:"bootstrapEnabled"`
                                                                                    	FlushEnabled          *bool                   `yaml:"flushEnabled"`
                                                                                    	WritesToCommitLog     *bool                   `yaml:"writesToCommitLog"`
                                                                                    	CleanupEnabled        *bool                   `yaml:"cleanupEnabled"`
                                                                                    	RepairEnabled         *bool                   `yaml:"repairEnabled"`
                                                                                    	ColdWritesEnabled     *bool                   `yaml:"coldWritesEnabled"`
                                                                                    	CacheBlocksOnRetrieve *bool                   `yaml:"cacheBlocksOnRetrieve"`
                                                                                    	Retention             retention.Configuration `yaml:"retention" validate:"nonzero"`
                                                                                    	Index                 IndexConfiguration      `yaml:"index"`
                                                                                    }

                                                                                      MetadataConfiguration is the configuration for a single namespace

                                                                                      func (*MetadataConfiguration) Metadata

                                                                                      func (mc *MetadataConfiguration) Metadata() (Metadata, error)

                                                                                        Metadata returns a Metadata corresponding to the receiver struct

                                                                                        type MetadataMatcher

                                                                                        type MetadataMatcher interface {
                                                                                        	gomock.Matcher
                                                                                        }

                                                                                          MetadataMatcher is a gomock.Matcher that matches metadata

                                                                                          func NewMetadataMatcher

                                                                                          func NewMetadataMatcher(md Metadata) MetadataMatcher

                                                                                            NewMetadataMatcher returns a new MetadataMatcher

                                                                                            type MockAggregationOptions

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

                                                                                              MockAggregationOptions is a mock of AggregationOptions interface

                                                                                              func NewMockAggregationOptions

                                                                                              func NewMockAggregationOptions(ctrl *gomock.Controller) *MockAggregationOptions

                                                                                                NewMockAggregationOptions creates a new mock instance

                                                                                                func (*MockAggregationOptions) Aggregations

                                                                                                func (m *MockAggregationOptions) Aggregations() []Aggregation

                                                                                                  Aggregations mocks base method

                                                                                                  func (*MockAggregationOptions) EXPECT

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

                                                                                                    func (*MockAggregationOptions) Equal

                                                                                                      Equal mocks base method

                                                                                                      func (*MockAggregationOptions) SetAggregations

                                                                                                      func (m *MockAggregationOptions) SetAggregations(value []Aggregation) AggregationOptions

                                                                                                        SetAggregations mocks base method

                                                                                                        type MockAggregationOptionsMockRecorder

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

                                                                                                          MockAggregationOptionsMockRecorder is the mock recorder for MockAggregationOptions

                                                                                                          func (*MockAggregationOptionsMockRecorder) Aggregations

                                                                                                          func (mr *MockAggregationOptionsMockRecorder) Aggregations() *gomock.Call

                                                                                                            Aggregations indicates an expected call of Aggregations

                                                                                                            func (*MockAggregationOptionsMockRecorder) Equal

                                                                                                            func (mr *MockAggregationOptionsMockRecorder) Equal(value interface{}) *gomock.Call

                                                                                                              Equal indicates an expected call of Equal

                                                                                                              func (*MockAggregationOptionsMockRecorder) SetAggregations

                                                                                                              func (mr *MockAggregationOptionsMockRecorder) SetAggregations(value interface{}) *gomock.Call

                                                                                                                SetAggregations indicates an expected call of SetAggregations

                                                                                                                type MockDynamicOptions

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

                                                                                                                  MockDynamicOptions is a mock of DynamicOptions interface

                                                                                                                  func NewMockDynamicOptions

                                                                                                                  func NewMockDynamicOptions(ctrl *gomock.Controller) *MockDynamicOptions

                                                                                                                    NewMockDynamicOptions creates a new mock instance

                                                                                                                    func (*MockDynamicOptions) AllowEmptyInitialNamespaceRegistry

                                                                                                                    func (m *MockDynamicOptions) AllowEmptyInitialNamespaceRegistry() bool

                                                                                                                      AllowEmptyInitialNamespaceRegistry mocks base method

                                                                                                                      func (*MockDynamicOptions) ConfigServiceClient

                                                                                                                      func (m *MockDynamicOptions) ConfigServiceClient() client.Client

                                                                                                                        ConfigServiceClient mocks base method

                                                                                                                        func (*MockDynamicOptions) EXPECT

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

                                                                                                                          func (*MockDynamicOptions) ForceColdWritesEnabled

                                                                                                                          func (m *MockDynamicOptions) ForceColdWritesEnabled() bool

                                                                                                                            ForceColdWritesEnabled mocks base method

                                                                                                                            func (*MockDynamicOptions) InstrumentOptions

                                                                                                                            func (m *MockDynamicOptions) InstrumentOptions() instrument.Options

                                                                                                                              InstrumentOptions mocks base method

                                                                                                                              func (*MockDynamicOptions) NamespaceRegistryKey

                                                                                                                              func (m *MockDynamicOptions) NamespaceRegistryKey() string

                                                                                                                                NamespaceRegistryKey mocks base method

                                                                                                                                func (*MockDynamicOptions) SetAllowEmptyInitialNamespaceRegistry

                                                                                                                                func (m *MockDynamicOptions) SetAllowEmptyInitialNamespaceRegistry(value bool) DynamicOptions

                                                                                                                                  SetAllowEmptyInitialNamespaceRegistry mocks base method

                                                                                                                                  func (*MockDynamicOptions) SetConfigServiceClient

                                                                                                                                  func (m *MockDynamicOptions) SetConfigServiceClient(c client.Client) DynamicOptions

                                                                                                                                    SetConfigServiceClient mocks base method

                                                                                                                                    func (*MockDynamicOptions) SetForceColdWritesEnabled

                                                                                                                                    func (m *MockDynamicOptions) SetForceColdWritesEnabled(enabled bool) DynamicOptions

                                                                                                                                      SetForceColdWritesEnabled mocks base method

                                                                                                                                      func (*MockDynamicOptions) SetInstrumentOptions

                                                                                                                                      func (m *MockDynamicOptions) SetInstrumentOptions(value instrument.Options) DynamicOptions

                                                                                                                                        SetInstrumentOptions mocks base method

                                                                                                                                        func (*MockDynamicOptions) SetNamespaceRegistryKey

                                                                                                                                        func (m *MockDynamicOptions) SetNamespaceRegistryKey(k string) DynamicOptions

                                                                                                                                          SetNamespaceRegistryKey mocks base method

                                                                                                                                          func (*MockDynamicOptions) Validate

                                                                                                                                          func (m *MockDynamicOptions) Validate() error

                                                                                                                                            Validate mocks base method

                                                                                                                                            type MockDynamicOptionsMockRecorder

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

                                                                                                                                              MockDynamicOptionsMockRecorder is the mock recorder for MockDynamicOptions

                                                                                                                                              func (*MockDynamicOptionsMockRecorder) AllowEmptyInitialNamespaceRegistry

                                                                                                                                              func (mr *MockDynamicOptionsMockRecorder) AllowEmptyInitialNamespaceRegistry() *gomock.Call

                                                                                                                                                AllowEmptyInitialNamespaceRegistry indicates an expected call of AllowEmptyInitialNamespaceRegistry

                                                                                                                                                func (*MockDynamicOptionsMockRecorder) ConfigServiceClient

                                                                                                                                                func (mr *MockDynamicOptionsMockRecorder) ConfigServiceClient() *gomock.Call

                                                                                                                                                  ConfigServiceClient indicates an expected call of ConfigServiceClient

                                                                                                                                                  func (*MockDynamicOptionsMockRecorder) ForceColdWritesEnabled

                                                                                                                                                  func (mr *MockDynamicOptionsMockRecorder) ForceColdWritesEnabled() *gomock.Call

                                                                                                                                                    ForceColdWritesEnabled indicates an expected call of ForceColdWritesEnabled

                                                                                                                                                    func (*MockDynamicOptionsMockRecorder) InstrumentOptions

                                                                                                                                                    func (mr *MockDynamicOptionsMockRecorder) InstrumentOptions() *gomock.Call

                                                                                                                                                      InstrumentOptions indicates an expected call of InstrumentOptions

                                                                                                                                                      func (*MockDynamicOptionsMockRecorder) NamespaceRegistryKey

                                                                                                                                                      func (mr *MockDynamicOptionsMockRecorder) NamespaceRegistryKey() *gomock.Call

                                                                                                                                                        NamespaceRegistryKey indicates an expected call of NamespaceRegistryKey

                                                                                                                                                        func (*MockDynamicOptionsMockRecorder) SetAllowEmptyInitialNamespaceRegistry

                                                                                                                                                        func (mr *MockDynamicOptionsMockRecorder) SetAllowEmptyInitialNamespaceRegistry(value interface{}) *gomock.Call

                                                                                                                                                          SetAllowEmptyInitialNamespaceRegistry indicates an expected call of SetAllowEmptyInitialNamespaceRegistry

                                                                                                                                                          func (*MockDynamicOptionsMockRecorder) SetConfigServiceClient

                                                                                                                                                          func (mr *MockDynamicOptionsMockRecorder) SetConfigServiceClient(c interface{}) *gomock.Call

                                                                                                                                                            SetConfigServiceClient indicates an expected call of SetConfigServiceClient

                                                                                                                                                            func (*MockDynamicOptionsMockRecorder) SetForceColdWritesEnabled

                                                                                                                                                            func (mr *MockDynamicOptionsMockRecorder) SetForceColdWritesEnabled(enabled interface{}) *gomock.Call

                                                                                                                                                              SetForceColdWritesEnabled indicates an expected call of SetForceColdWritesEnabled

                                                                                                                                                              func (*MockDynamicOptionsMockRecorder) SetInstrumentOptions

                                                                                                                                                              func (mr *MockDynamicOptionsMockRecorder) SetInstrumentOptions(value interface{}) *gomock.Call

                                                                                                                                                                SetInstrumentOptions indicates an expected call of SetInstrumentOptions

                                                                                                                                                                func (*MockDynamicOptionsMockRecorder) SetNamespaceRegistryKey

                                                                                                                                                                func (mr *MockDynamicOptionsMockRecorder) SetNamespaceRegistryKey(k interface{}) *gomock.Call

                                                                                                                                                                  SetNamespaceRegistryKey indicates an expected call of SetNamespaceRegistryKey

                                                                                                                                                                  func (*MockDynamicOptionsMockRecorder) Validate

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

                                                                                                                                                                    Validate indicates an expected call of Validate

                                                                                                                                                                    type MockExtendedOptions

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

                                                                                                                                                                      MockExtendedOptions is a mock of ExtendedOptions interface

                                                                                                                                                                      func NewMockExtendedOptions

                                                                                                                                                                      func NewMockExtendedOptions(ctrl *gomock.Controller) *MockExtendedOptions

                                                                                                                                                                        NewMockExtendedOptions creates a new mock instance

                                                                                                                                                                        func (*MockExtendedOptions) EXPECT

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

                                                                                                                                                                          func (*MockExtendedOptions) ToProto

                                                                                                                                                                          func (m *MockExtendedOptions) ToProto() (proto.Message, string)

                                                                                                                                                                            ToProto mocks base method

                                                                                                                                                                            func (*MockExtendedOptions) Validate

                                                                                                                                                                            func (m *MockExtendedOptions) Validate() error

                                                                                                                                                                              Validate mocks base method

                                                                                                                                                                              type MockExtendedOptionsMockRecorder

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

                                                                                                                                                                                MockExtendedOptionsMockRecorder is the mock recorder for MockExtendedOptions

                                                                                                                                                                                func (*MockExtendedOptionsMockRecorder) ToProto

                                                                                                                                                                                  ToProto indicates an expected call of ToProto

                                                                                                                                                                                  func (*MockExtendedOptionsMockRecorder) Validate

                                                                                                                                                                                    Validate indicates an expected call of Validate

                                                                                                                                                                                    type MockIndexOptions

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

                                                                                                                                                                                      MockIndexOptions is a mock of IndexOptions interface

                                                                                                                                                                                      func NewMockIndexOptions

                                                                                                                                                                                      func NewMockIndexOptions(ctrl *gomock.Controller) *MockIndexOptions

                                                                                                                                                                                        NewMockIndexOptions creates a new mock instance

                                                                                                                                                                                        func (*MockIndexOptions) BlockSize

                                                                                                                                                                                        func (m *MockIndexOptions) BlockSize() time.Duration

                                                                                                                                                                                          BlockSize mocks base method

                                                                                                                                                                                          func (*MockIndexOptions) EXPECT

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

                                                                                                                                                                                            func (*MockIndexOptions) Enabled

                                                                                                                                                                                            func (m *MockIndexOptions) Enabled() bool

                                                                                                                                                                                              Enabled mocks base method

                                                                                                                                                                                              func (*MockIndexOptions) Equal

                                                                                                                                                                                              func (m *MockIndexOptions) Equal(value IndexOptions) bool

                                                                                                                                                                                                Equal mocks base method

                                                                                                                                                                                                func (*MockIndexOptions) SetBlockSize

                                                                                                                                                                                                func (m *MockIndexOptions) SetBlockSize(value time.Duration) IndexOptions

                                                                                                                                                                                                  SetBlockSize mocks base method

                                                                                                                                                                                                  func (*MockIndexOptions) SetEnabled

                                                                                                                                                                                                  func (m *MockIndexOptions) SetEnabled(value bool) IndexOptions

                                                                                                                                                                                                    SetEnabled mocks base method

                                                                                                                                                                                                    type MockIndexOptionsMockRecorder

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

                                                                                                                                                                                                      MockIndexOptionsMockRecorder is the mock recorder for MockIndexOptions

                                                                                                                                                                                                      func (*MockIndexOptionsMockRecorder) BlockSize

                                                                                                                                                                                                      func (mr *MockIndexOptionsMockRecorder) BlockSize() *gomock.Call

                                                                                                                                                                                                        BlockSize indicates an expected call of BlockSize

                                                                                                                                                                                                        func (*MockIndexOptionsMockRecorder) Enabled

                                                                                                                                                                                                        func (mr *MockIndexOptionsMockRecorder) Enabled() *gomock.Call

                                                                                                                                                                                                          Enabled indicates an expected call of Enabled

                                                                                                                                                                                                          func (*MockIndexOptionsMockRecorder) Equal

                                                                                                                                                                                                          func (mr *MockIndexOptionsMockRecorder) Equal(value interface{}) *gomock.Call

                                                                                                                                                                                                            Equal indicates an expected call of Equal

                                                                                                                                                                                                            func (*MockIndexOptionsMockRecorder) SetBlockSize

                                                                                                                                                                                                            func (mr *MockIndexOptionsMockRecorder) SetBlockSize(value interface{}) *gomock.Call

                                                                                                                                                                                                              SetBlockSize indicates an expected call of SetBlockSize

                                                                                                                                                                                                              func (*MockIndexOptionsMockRecorder) SetEnabled

                                                                                                                                                                                                              func (mr *MockIndexOptionsMockRecorder) SetEnabled(value interface{}) *gomock.Call

                                                                                                                                                                                                                SetEnabled indicates an expected call of SetEnabled

                                                                                                                                                                                                                type MockInitializer

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

                                                                                                                                                                                                                  MockInitializer is a mock of Initializer interface

                                                                                                                                                                                                                  func NewMockInitializer

                                                                                                                                                                                                                  func NewMockInitializer(ctrl *gomock.Controller) *MockInitializer

                                                                                                                                                                                                                    NewMockInitializer creates a new mock instance

                                                                                                                                                                                                                    func (*MockInitializer) EXPECT

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

                                                                                                                                                                                                                      func (*MockInitializer) Init

                                                                                                                                                                                                                      func (m *MockInitializer) Init() (Registry, error)

                                                                                                                                                                                                                        Init mocks base method

                                                                                                                                                                                                                        type MockInitializerMockRecorder

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

                                                                                                                                                                                                                          MockInitializerMockRecorder is the mock recorder for MockInitializer

                                                                                                                                                                                                                          func (*MockInitializerMockRecorder) Init

                                                                                                                                                                                                                            Init indicates an expected call of Init

                                                                                                                                                                                                                            type MockMap

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

                                                                                                                                                                                                                              MockMap is a mock of Map interface

                                                                                                                                                                                                                              func NewMockMap

                                                                                                                                                                                                                              func NewMockMap(ctrl *gomock.Controller) *MockMap

                                                                                                                                                                                                                                NewMockMap creates a new mock instance

                                                                                                                                                                                                                                func (*MockMap) EXPECT

                                                                                                                                                                                                                                func (m *MockMap) EXPECT() *MockMapMockRecorder

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

                                                                                                                                                                                                                                  func (*MockMap) Equal

                                                                                                                                                                                                                                  func (m *MockMap) Equal(value Map) bool

                                                                                                                                                                                                                                    Equal mocks base method

                                                                                                                                                                                                                                    func (*MockMap) Get

                                                                                                                                                                                                                                    func (m *MockMap) Get(arg0 ident.ID) (Metadata, error)

                                                                                                                                                                                                                                      Get mocks base method

                                                                                                                                                                                                                                      func (*MockMap) IDs

                                                                                                                                                                                                                                      func (m *MockMap) IDs() []ident.ID

                                                                                                                                                                                                                                        IDs mocks base method

                                                                                                                                                                                                                                        func (*MockMap) Metadatas

                                                                                                                                                                                                                                        func (m *MockMap) Metadatas() []Metadata

                                                                                                                                                                                                                                          Metadatas mocks base method

                                                                                                                                                                                                                                          type MockMapMockRecorder

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

                                                                                                                                                                                                                                            MockMapMockRecorder is the mock recorder for MockMap

                                                                                                                                                                                                                                            func (*MockMapMockRecorder) Equal

                                                                                                                                                                                                                                            func (mr *MockMapMockRecorder) Equal(value interface{}) *gomock.Call

                                                                                                                                                                                                                                              Equal indicates an expected call of Equal

                                                                                                                                                                                                                                              func (*MockMapMockRecorder) Get

                                                                                                                                                                                                                                              func (mr *MockMapMockRecorder) Get(arg0 interface{}) *gomock.Call

                                                                                                                                                                                                                                                Get indicates an expected call of Get

                                                                                                                                                                                                                                                func (*MockMapMockRecorder) IDs

                                                                                                                                                                                                                                                func (mr *MockMapMockRecorder) IDs() *gomock.Call

                                                                                                                                                                                                                                                  IDs indicates an expected call of IDs

                                                                                                                                                                                                                                                  func (*MockMapMockRecorder) Metadatas

                                                                                                                                                                                                                                                  func (mr *MockMapMockRecorder) Metadatas() *gomock.Call

                                                                                                                                                                                                                                                    Metadatas indicates an expected call of Metadatas

                                                                                                                                                                                                                                                    type MockMetadata

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

                                                                                                                                                                                                                                                      MockMetadata is a mock of Metadata interface

                                                                                                                                                                                                                                                      func NewMockMetadata

                                                                                                                                                                                                                                                      func NewMockMetadata(ctrl *gomock.Controller) *MockMetadata

                                                                                                                                                                                                                                                        NewMockMetadata creates a new mock instance

                                                                                                                                                                                                                                                        func (*MockMetadata) EXPECT

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

                                                                                                                                                                                                                                                          func (*MockMetadata) Equal

                                                                                                                                                                                                                                                          func (m *MockMetadata) Equal(value Metadata) bool

                                                                                                                                                                                                                                                            Equal mocks base method

                                                                                                                                                                                                                                                            func (*MockMetadata) ID

                                                                                                                                                                                                                                                            func (m *MockMetadata) ID() ident.ID

                                                                                                                                                                                                                                                              ID mocks base method

                                                                                                                                                                                                                                                              func (*MockMetadata) Options

                                                                                                                                                                                                                                                              func (m *MockMetadata) Options() Options

                                                                                                                                                                                                                                                                Options mocks base method

                                                                                                                                                                                                                                                                type MockMetadataMockRecorder

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

                                                                                                                                                                                                                                                                  MockMetadataMockRecorder is the mock recorder for MockMetadata

                                                                                                                                                                                                                                                                  func (*MockMetadataMockRecorder) Equal

                                                                                                                                                                                                                                                                  func (mr *MockMetadataMockRecorder) Equal(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                    Equal indicates an expected call of Equal

                                                                                                                                                                                                                                                                    func (*MockMetadataMockRecorder) ID

                                                                                                                                                                                                                                                                      ID indicates an expected call of ID

                                                                                                                                                                                                                                                                      func (*MockMetadataMockRecorder) Options

                                                                                                                                                                                                                                                                      func (mr *MockMetadataMockRecorder) Options() *gomock.Call

                                                                                                                                                                                                                                                                        Options indicates an expected call of Options

                                                                                                                                                                                                                                                                        type MockNamespaceWatch

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

                                                                                                                                                                                                                                                                          MockNamespaceWatch is a mock of NamespaceWatch interface

                                                                                                                                                                                                                                                                          func NewMockNamespaceWatch

                                                                                                                                                                                                                                                                          func NewMockNamespaceWatch(ctrl *gomock.Controller) *MockNamespaceWatch

                                                                                                                                                                                                                                                                            NewMockNamespaceWatch creates a new mock instance

                                                                                                                                                                                                                                                                            func (*MockNamespaceWatch) Close

                                                                                                                                                                                                                                                                            func (m *MockNamespaceWatch) Close() error

                                                                                                                                                                                                                                                                              Close mocks base method

                                                                                                                                                                                                                                                                              func (*MockNamespaceWatch) EXPECT

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

                                                                                                                                                                                                                                                                                func (*MockNamespaceWatch) Start

                                                                                                                                                                                                                                                                                func (m *MockNamespaceWatch) Start() error

                                                                                                                                                                                                                                                                                  Start mocks base method

                                                                                                                                                                                                                                                                                  func (*MockNamespaceWatch) Stop

                                                                                                                                                                                                                                                                                  func (m *MockNamespaceWatch) Stop() error

                                                                                                                                                                                                                                                                                    Stop mocks base method

                                                                                                                                                                                                                                                                                    type MockNamespaceWatchMockRecorder

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

                                                                                                                                                                                                                                                                                      MockNamespaceWatchMockRecorder is the mock recorder for MockNamespaceWatch

                                                                                                                                                                                                                                                                                      func (*MockNamespaceWatchMockRecorder) Close

                                                                                                                                                                                                                                                                                        Close indicates an expected call of Close

                                                                                                                                                                                                                                                                                        func (*MockNamespaceWatchMockRecorder) Start

                                                                                                                                                                                                                                                                                          Start indicates an expected call of Start

                                                                                                                                                                                                                                                                                          func (*MockNamespaceWatchMockRecorder) Stop

                                                                                                                                                                                                                                                                                            Stop indicates an expected call of Stop

                                                                                                                                                                                                                                                                                            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) AggregationOptions

                                                                                                                                                                                                                                                                                                func (m *MockOptions) AggregationOptions() AggregationOptions

                                                                                                                                                                                                                                                                                                  AggregationOptions mocks base method

                                                                                                                                                                                                                                                                                                  func (*MockOptions) BootstrapEnabled

                                                                                                                                                                                                                                                                                                  func (m *MockOptions) BootstrapEnabled() bool

                                                                                                                                                                                                                                                                                                    BootstrapEnabled mocks base method

                                                                                                                                                                                                                                                                                                    func (*MockOptions) CacheBlocksOnRetrieve

                                                                                                                                                                                                                                                                                                    func (m *MockOptions) CacheBlocksOnRetrieve() bool

                                                                                                                                                                                                                                                                                                      CacheBlocksOnRetrieve mocks base method

                                                                                                                                                                                                                                                                                                      func (*MockOptions) CleanupEnabled

                                                                                                                                                                                                                                                                                                      func (m *MockOptions) CleanupEnabled() bool

                                                                                                                                                                                                                                                                                                        CleanupEnabled mocks base method

                                                                                                                                                                                                                                                                                                        func (*MockOptions) ColdWritesEnabled

                                                                                                                                                                                                                                                                                                        func (m *MockOptions) ColdWritesEnabled() bool

                                                                                                                                                                                                                                                                                                          ColdWritesEnabled 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) Equal

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

                                                                                                                                                                                                                                                                                                              Equal mocks base method

                                                                                                                                                                                                                                                                                                              func (*MockOptions) ExtendedOptions

                                                                                                                                                                                                                                                                                                              func (m *MockOptions) ExtendedOptions() ExtendedOptions

                                                                                                                                                                                                                                                                                                                ExtendedOptions mocks base method

                                                                                                                                                                                                                                                                                                                func (*MockOptions) FlushEnabled

                                                                                                                                                                                                                                                                                                                func (m *MockOptions) FlushEnabled() bool

                                                                                                                                                                                                                                                                                                                  FlushEnabled mocks base method

                                                                                                                                                                                                                                                                                                                  func (*MockOptions) IndexOptions

                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) IndexOptions() IndexOptions

                                                                                                                                                                                                                                                                                                                    IndexOptions mocks base method

                                                                                                                                                                                                                                                                                                                    func (*MockOptions) RepairEnabled

                                                                                                                                                                                                                                                                                                                    func (m *MockOptions) RepairEnabled() bool

                                                                                                                                                                                                                                                                                                                      RepairEnabled mocks base method

                                                                                                                                                                                                                                                                                                                      func (*MockOptions) RetentionOptions

                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) RetentionOptions() retention.Options

                                                                                                                                                                                                                                                                                                                        RetentionOptions mocks base method

                                                                                                                                                                                                                                                                                                                        func (*MockOptions) RuntimeOptions

                                                                                                                                                                                                                                                                                                                        func (m *MockOptions) RuntimeOptions() RuntimeOptions

                                                                                                                                                                                                                                                                                                                          RuntimeOptions mocks base method

                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SchemaHistory

                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SchemaHistory() SchemaHistory

                                                                                                                                                                                                                                                                                                                            SchemaHistory mocks base method

                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetAggregationOptions

                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) SetAggregationOptions(value AggregationOptions) Options

                                                                                                                                                                                                                                                                                                                              SetAggregationOptions mocks base method

                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetBootstrapEnabled

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

                                                                                                                                                                                                                                                                                                                                SetBootstrapEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetCacheBlocksOnRetrieve

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

                                                                                                                                                                                                                                                                                                                                  SetCacheBlocksOnRetrieve mocks base method

                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetCleanupEnabled

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

                                                                                                                                                                                                                                                                                                                                    SetCleanupEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetColdWritesEnabled

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

                                                                                                                                                                                                                                                                                                                                      SetColdWritesEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetExtendedOptions

                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetExtendedOptions(value ExtendedOptions) Options

                                                                                                                                                                                                                                                                                                                                        SetExtendedOptions mocks base method

                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetFlushEnabled

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

                                                                                                                                                                                                                                                                                                                                          SetFlushEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SetIndexOptions

                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SetIndexOptions(value IndexOptions) Options

                                                                                                                                                                                                                                                                                                                                            SetIndexOptions mocks base method

                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) SetRepairEnabled

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

                                                                                                                                                                                                                                                                                                                                              SetRepairEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) SetRetentionOptions

                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) SetRetentionOptions(value retention.Options) Options

                                                                                                                                                                                                                                                                                                                                                SetRetentionOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) SetRuntimeOptions

                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) SetRuntimeOptions(value RuntimeOptions) Options

                                                                                                                                                                                                                                                                                                                                                  SetRuntimeOptions mocks base method

                                                                                                                                                                                                                                                                                                                                                  func (*MockOptions) SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                  func (m *MockOptions) SetSchemaHistory(value SchemaHistory) Options

                                                                                                                                                                                                                                                                                                                                                    SetSchemaHistory mocks base method

                                                                                                                                                                                                                                                                                                                                                    func (*MockOptions) SetSnapshotEnabled

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

                                                                                                                                                                                                                                                                                                                                                      SetSnapshotEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                                      func (*MockOptions) SetStagingState

                                                                                                                                                                                                                                                                                                                                                      func (m *MockOptions) SetStagingState(value StagingState) Options

                                                                                                                                                                                                                                                                                                                                                        SetStagingState mocks base method

                                                                                                                                                                                                                                                                                                                                                        func (*MockOptions) SetWritesToCommitLog

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

                                                                                                                                                                                                                                                                                                                                                          SetWritesToCommitLog mocks base method

                                                                                                                                                                                                                                                                                                                                                          func (*MockOptions) SnapshotEnabled

                                                                                                                                                                                                                                                                                                                                                          func (m *MockOptions) SnapshotEnabled() bool

                                                                                                                                                                                                                                                                                                                                                            SnapshotEnabled mocks base method

                                                                                                                                                                                                                                                                                                                                                            func (*MockOptions) StagingState

                                                                                                                                                                                                                                                                                                                                                            func (m *MockOptions) StagingState() StagingState

                                                                                                                                                                                                                                                                                                                                                              StagingState mocks base method

                                                                                                                                                                                                                                                                                                                                                              func (*MockOptions) Validate

                                                                                                                                                                                                                                                                                                                                                              func (m *MockOptions) Validate() error

                                                                                                                                                                                                                                                                                                                                                                Validate mocks base method

                                                                                                                                                                                                                                                                                                                                                                func (*MockOptions) WritesToCommitLog

                                                                                                                                                                                                                                                                                                                                                                func (m *MockOptions) WritesToCommitLog() bool

                                                                                                                                                                                                                                                                                                                                                                  WritesToCommitLog mocks base method

                                                                                                                                                                                                                                                                                                                                                                  type MockOptionsMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                    MockOptionsMockRecorder is the mock recorder for MockOptions

                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) AggregationOptions

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

                                                                                                                                                                                                                                                                                                                                                                      AggregationOptions indicates an expected call of AggregationOptions

                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) BootstrapEnabled

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

                                                                                                                                                                                                                                                                                                                                                                        BootstrapEnabled indicates an expected call of BootstrapEnabled

                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) CacheBlocksOnRetrieve

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

                                                                                                                                                                                                                                                                                                                                                                          CacheBlocksOnRetrieve indicates an expected call of CacheBlocksOnRetrieve

                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) CleanupEnabled

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

                                                                                                                                                                                                                                                                                                                                                                            CleanupEnabled indicates an expected call of CleanupEnabled

                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) ColdWritesEnabled

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

                                                                                                                                                                                                                                                                                                                                                                              ColdWritesEnabled indicates an expected call of ColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) Equal

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

                                                                                                                                                                                                                                                                                                                                                                                Equal indicates an expected call of Equal

                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) ExtendedOptions

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

                                                                                                                                                                                                                                                                                                                                                                                  ExtendedOptions indicates an expected call of ExtendedOptions

                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) FlushEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                    FlushEnabled indicates an expected call of FlushEnabled

                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) IndexOptions

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

                                                                                                                                                                                                                                                                                                                                                                                      IndexOptions indicates an expected call of IndexOptions

                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) RepairEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                        RepairEnabled indicates an expected call of RepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) RetentionOptions

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

                                                                                                                                                                                                                                                                                                                                                                                          RetentionOptions indicates an expected call of RetentionOptions

                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) RuntimeOptions

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

                                                                                                                                                                                                                                                                                                                                                                                            RuntimeOptions indicates an expected call of RuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SchemaHistory

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

                                                                                                                                                                                                                                                                                                                                                                                              SchemaHistory indicates an expected call of SchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetAggregationOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                SetAggregationOptions indicates an expected call of SetAggregationOptions

                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetBootstrapEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                  SetBootstrapEnabled indicates an expected call of SetBootstrapEnabled

                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetCacheBlocksOnRetrieve

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

                                                                                                                                                                                                                                                                                                                                                                                                    SetCacheBlocksOnRetrieve indicates an expected call of SetCacheBlocksOnRetrieve

                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetCleanupEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                      SetCleanupEnabled indicates an expected call of SetCleanupEnabled

                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetColdWritesEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                        SetColdWritesEnabled indicates an expected call of SetColdWritesEnabled

                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetExtendedOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                          SetExtendedOptions indicates an expected call of SetExtendedOptions

                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetFlushEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                            SetFlushEnabled indicates an expected call of SetFlushEnabled

                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SetIndexOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                              SetIndexOptions indicates an expected call of SetIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) SetRepairEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                                SetRepairEnabled indicates an expected call of SetRepairEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) SetRetentionOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                  SetRetentionOptions indicates an expected call of SetRetentionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) SetRuntimeOptions

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

                                                                                                                                                                                                                                                                                                                                                                                                                    SetRuntimeOptions indicates an expected call of SetRuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockOptionsMockRecorder) SetSchemaHistory

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

                                                                                                                                                                                                                                                                                                                                                                                                                      SetSchemaHistory indicates an expected call of SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockOptionsMockRecorder) SetSnapshotEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                                        SetSnapshotEnabled indicates an expected call of SetSnapshotEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockOptionsMockRecorder) SetStagingState

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

                                                                                                                                                                                                                                                                                                                                                                                                                          SetStagingState indicates an expected call of SetStagingState

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockOptionsMockRecorder) SetWritesToCommitLog

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

                                                                                                                                                                                                                                                                                                                                                                                                                            SetWritesToCommitLog indicates an expected call of SetWritesToCommitLog

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockOptionsMockRecorder) SnapshotEnabled

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

                                                                                                                                                                                                                                                                                                                                                                                                                              SnapshotEnabled indicates an expected call of SnapshotEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockOptionsMockRecorder) StagingState

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

                                                                                                                                                                                                                                                                                                                                                                                                                                StagingState indicates an expected call of StagingState

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockOptionsMockRecorder) Validate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                  Validate indicates an expected call of Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockOptionsMockRecorder) WritesToCommitLog

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

                                                                                                                                                                                                                                                                                                                                                                                                                                    WritesToCommitLog indicates an expected call of WritesToCommitLog

                                                                                                                                                                                                                                                                                                                                                                                                                                    type MockRegistry

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

                                                                                                                                                                                                                                                                                                                                                                                                                                      MockRegistry is a mock of Registry interface

                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewMockRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewMockRegistry(ctrl *gomock.Controller) *MockRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                        NewMockRegistry creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockRegistry) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockRegistry) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                          Close mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockRegistry) EXPECT

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockRegistry) Watch

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockRegistry) Watch() (Watch, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                              Watch mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockRegistryMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                MockRegistryMockRecorder is the mock recorder for MockRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockRegistryMockRecorder) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockRegistryMockRecorder) Close() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Close indicates an expected call of Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockRegistryMockRecorder) Watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockRegistryMockRecorder) Watch() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Watch indicates an expected call of Watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MockSchemaDescr

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                      MockSchemaDescr is a mock of SchemaDescr interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewMockSchemaDescr

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewMockSchemaDescr(ctrl *gomock.Controller) *MockSchemaDescr

                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewMockSchemaDescr creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockSchemaDescr) DeployId

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockSchemaDescr) DeployId() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                          DeployId mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockSchemaDescr) EXPECT

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockSchemaDescr) Equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockSchemaDescr) Equal(arg0 SchemaDescr) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Equal mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockSchemaDescr) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Get mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockSchemaDescr) PrevDeployId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockSchemaDescr) PrevDeployId() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  PrevDeployId mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockSchemaDescr) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockSchemaDescr) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    String mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MockSchemaDescrMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MockSchemaDescrMockRecorder is the mock recorder for MockSchemaDescr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockSchemaDescrMockRecorder) DeployId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockSchemaDescrMockRecorder) DeployId() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DeployId indicates an expected call of DeployId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockSchemaDescrMockRecorder) Equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockSchemaDescrMockRecorder) Equal(arg0 interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Equal indicates an expected call of Equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockSchemaDescrMockRecorder) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Get indicates an expected call of Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockSchemaDescrMockRecorder) PrevDeployId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockSchemaDescrMockRecorder) PrevDeployId() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PrevDeployId indicates an expected call of PrevDeployId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockSchemaDescrMockRecorder) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockSchemaDescrMockRecorder) String() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                String indicates an expected call of String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MockSchemaHistory

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MockSchemaHistory is a mock of SchemaHistory interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewMockSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewMockSchemaHistory(ctrl *gomock.Controller) *MockSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewMockSchemaHistory creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockSchemaHistory) EXPECT

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockSchemaHistory) Equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockSchemaHistory) Equal(arg0 SchemaHistory) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Equal mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockSchemaHistory) Extends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockSchemaHistory) Extends(arg0 SchemaHistory) bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Extends mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockSchemaHistory) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockSchemaHistory) Get(id string) (SchemaDescr, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Get mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockSchemaHistory) GetLatest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockSchemaHistory) GetLatest() (SchemaDescr, bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetLatest mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MockSchemaHistoryMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MockSchemaHistoryMockRecorder is the mock recorder for MockSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockSchemaHistoryMockRecorder) Equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockSchemaHistoryMockRecorder) Equal(arg0 interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Equal indicates an expected call of Equal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockSchemaHistoryMockRecorder) Extends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockSchemaHistoryMockRecorder) Extends(arg0 interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extends indicates an expected call of Extends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockSchemaHistoryMockRecorder) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (mr *MockSchemaHistoryMockRecorder) Get(id interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Get indicates an expected call of Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockSchemaHistoryMockRecorder) GetLatest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (mr *MockSchemaHistoryMockRecorder) GetLatest() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetLatest indicates an expected call of GetLatest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MockSchemaListener

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MockSchemaListener is a mock of SchemaListener interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewMockSchemaListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewMockSchemaListener(ctrl *gomock.Controller) *MockSchemaListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewMockSchemaListener creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockSchemaListener) EXPECT

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockSchemaListener) SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockSchemaListener) SetSchemaHistory(value SchemaHistory)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetSchemaHistory mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MockSchemaListenerMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MockSchemaListenerMockRecorder is the mock recorder for MockSchemaListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockSchemaListenerMockRecorder) SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockSchemaListenerMockRecorder) SetSchemaHistory(value interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSchemaHistory indicates an expected call of SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MockSchemaRegistry

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MockSchemaRegistry is a mock of SchemaRegistry interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewMockSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewMockSchemaRegistry(ctrl *gomock.Controller) *MockSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewMockSchemaRegistry creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockSchemaRegistry) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockSchemaRegistry) Close()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Close mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockSchemaRegistry) EXPECT

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockSchemaRegistry) GetLatestSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *MockSchemaRegistry) GetLatestSchema(id ident.ID) (SchemaDescr, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetLatestSchema mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockSchemaRegistry) GetSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *MockSchemaRegistry) GetSchema(id ident.ID, schemaID string) (SchemaDescr, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetSchema mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockSchemaRegistry) RegisterListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *MockSchemaRegistry) RegisterListener(id ident.ID, listener SchemaListener) (resource.SimpleCloser, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RegisterListener mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockSchemaRegistry) SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *MockSchemaRegistry) SetSchemaHistory(id ident.ID, history SchemaHistory) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSchemaHistory mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MockSchemaRegistryMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MockSchemaRegistryMockRecorder is the mock recorder for MockSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockSchemaRegistryMockRecorder) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Close indicates an expected call of Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockSchemaRegistryMockRecorder) GetLatestSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (mr *MockSchemaRegistryMockRecorder) GetLatestSchema(id interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetLatestSchema indicates an expected call of GetLatestSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockSchemaRegistryMockRecorder) GetSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (mr *MockSchemaRegistryMockRecorder) GetSchema(id, schemaID interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetSchema indicates an expected call of GetSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*MockSchemaRegistryMockRecorder) RegisterListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (mr *MockSchemaRegistryMockRecorder) RegisterListener(id, listener interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RegisterListener indicates an expected call of RegisterListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockSchemaRegistryMockRecorder) SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (mr *MockSchemaRegistryMockRecorder) SetSchemaHistory(id, history interface{}) *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetSchemaHistory indicates an expected call of SetSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MockWatch

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MockWatch is a mock of Watch interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewMockWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewMockWatch(ctrl *gomock.Controller) *MockWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewMockWatch creates a new mock instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*MockWatch) C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *MockWatch) C() <-chan struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      C mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*MockWatch) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *MockWatch) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Close mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*MockWatch) EXPECT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *MockWatch) EXPECT() *MockWatchMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*MockWatch) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *MockWatch) Get() Map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Get mocks base method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MockWatchMockRecorder

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MockWatchMockRecorder is the mock recorder for MockWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MockWatchMockRecorder) C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C indicates an expected call of C

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MockWatchMockRecorder) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (mr *MockWatchMockRecorder) Close() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Close indicates an expected call of Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*MockWatchMockRecorder) Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (mr *MockWatchMockRecorder) Get() *gomock.Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Get indicates an expected call of Get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NamespaceUpdater

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NamespaceUpdater func(Map) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NamespaceUpdater is a namespace updater function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NamespaceWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NamespaceWatch interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Start starts the namespace watch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Start() error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Stop stops the namespace watch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Stop() error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// close stops the watch, and releases any held resources.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Close() error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NamespaceWatch watches for namespace updates.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewNamespaceWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewNamespaceWatch(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	update NamespaceUpdater,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	w Watch,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	iopts instrument.Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) NamespaceWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Options interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Validate validates the options.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Validate() error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Equal returns true if the provide value is equal to this one.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Equal(value Options) bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetBootstrapEnabled sets whether this namespace requires bootstrapping.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetBootstrapEnabled(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// BootstrapEnabled returns whether this namespace requires bootstrapping.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BootstrapEnabled() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetFlushEnabled sets whether the in-memory data for this namespace needs to be flushed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetFlushEnabled(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// FlushEnabled returns whether the in-memory data for this namespace needs to be flushed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FlushEnabled() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetSnapshotEnabled sets whether the in-memory data for this namespace should be snapshotted regularly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetSnapshotEnabled(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SnapshotEnabled returns whether the in-memory data for this namespace should be snapshotted regularly.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SnapshotEnabled() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetWritesToCommitLog sets whether writes for series in this namespace need to go to commit log.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetWritesToCommitLog(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// WritesToCommitLog returns whether writes for series in this namespace need to go to commit log.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WritesToCommitLog() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetCleanupEnabled sets whether this namespace requires cleaning up fileset/snapshot files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetCleanupEnabled(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// CleanupEnabled returns whether this namespace requires cleaning up fileset/snapshot files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CleanupEnabled() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetRepairEnabled sets whether the data for this namespace needs to be repaired.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetRepairEnabled(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// RepairEnabled returns whether the data for this namespace needs to be repaired.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	RepairEnabled() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetColdWritesEnabled sets whether cold writes are enabled for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetColdWritesEnabled(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// ColdWritesEnabled returns whether cold writes are enabled for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ColdWritesEnabled() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetCacheBlocksOnRetrieve sets whether to cache blocks from this namespace when retrieved.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If global CacheBlocksOnRetrieve option in config.BlockRetrievePolicy is set to false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// then that will override any namespace-specific CacheBlocksOnRetrieve options set to true.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetCacheBlocksOnRetrieve(value bool) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// CacheBlocksOnRetrieve returns whether to cache blocks from this namespace when retrieved.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CacheBlocksOnRetrieve() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetRetentionOptions sets the retention options for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetRetentionOptions(value retention.Options) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// RetentionOptions returns the retention options for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	RetentionOptions() retention.Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetIndexOptions sets the IndexOptions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetIndexOptions(value IndexOptions) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// IndexOptions returns the IndexOptions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	IndexOptions() IndexOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetSchemaHistory sets the schema registry for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetSchemaHistory(value SchemaHistory) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SchemaHistory returns the schema registry for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SchemaHistory() SchemaHistory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetRuntimeOptions sets the RuntimeOptions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetRuntimeOptions(value RuntimeOptions) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// RuntimeOptions returns the RuntimeOptions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	RuntimeOptions() RuntimeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetExtendedOptions sets the ExtendedOptions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetExtendedOptions(value ExtendedOptions) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// ExtendedOptions returns the dynamically typed ExtendedOptions (requires type check on access).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ExtendedOptions() ExtendedOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetAggregationOptions sets the aggregation-related options for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetAggregationOptions(value AggregationOptions) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// AggregationOptions returns the aggregation-related options for this namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	AggregationOptions() AggregationOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetStagingState sets the state related to a namespace's availability for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetStagingState(value StagingState) Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// StagingState returns the state related to a namespace's availability for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	StagingState() StagingState
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Options controls namespace behavior.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewOptions() Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewOptions creates a new namespace options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Registry interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Watch for the Registry changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Watch() (Watch, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Close closes the registry.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Close() error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Registry is an un-changing container for a Map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RuntimeOptions interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// IsDefault returns whether the runtime options are purely defaults
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// with no values explicitly set.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	IsDefault() bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Equal will return whether it's equal to another runtime options.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Equal(other RuntimeOptions) bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// SetWriteIndexingPerCPUConcurrency sets the write
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// indexing per CPU concurrency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SetWriteIndexingPerCPUConcurrency(value *float64) RuntimeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// WriteIndexingPerCPUConcurrency returns the write
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// indexing per CPU concurrency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	WriteIndexingPerCPUConcurrency() *float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// WriteIndexingPerCPUConcurrencyOrDefault returns the write
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// indexing per CPU concurrency or default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	WriteIndexingPerCPUConcurrencyOrDefault() float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// SetFlushIndexingPerCPUConcurrency sets the flush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// indexing per CPU concurrency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SetFlushIndexingPerCPUConcurrency(value *float64) RuntimeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// FlushIndexingPerCPUConcurrency returns the flush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// indexing per CPU concurrency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FlushIndexingPerCPUConcurrency() *float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// FlushIndexingPerCPUConcurrencyOrDefault returns the flush
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// indexing per CPU concurrency.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FlushIndexingPerCPUConcurrencyOrDefault() float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RuntimeOptions is a set of runtime options that can be set per namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewRuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewRuntimeOptions() RuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewRuntimeOptions returns a new namespace runtime options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ToRuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ToRuntimeOptions(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	opts *nsproto.NamespaceRuntimeOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) (RuntimeOptions, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ToRuntimeOptions converts nsproto.NamespaceRuntimeOptions to RuntimeOptions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RuntimeOptionsListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RuntimeOptionsListener interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// SetNamespaceRuntimeOptions is called when the listener is registered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// and when any updates occurred passing the new runtime options.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	SetNamespaceRuntimeOptions(value RuntimeOptions)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RuntimeOptionsListener listens for updates to runtime options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RuntimeOptionsManager interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Update updates the current runtime options.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Update(value RuntimeOptions) error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Get returns the current values.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Get() RuntimeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// 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 RuntimeOptionsListener) xresource.SimpleCloser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Close closes the watcher and all descendent watches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Close()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RuntimeOptionsManager is a runtime options manager.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewRuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewRuntimeOptionsManager(namespace string) RuntimeOptionsManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewRuntimeOptionsManager returns a new runtime options manager.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RuntimeOptionsManagerRegistry interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// RuntimeOptionsManager returns a namespace runtime options manager
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// for the given namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RuntimeOptionsManager(namespace string) RuntimeOptionsManager
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Close closes the watcher and all descendent watches.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Close()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RuntimeOptionsManagerRegistry is a registry of runtime options managers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewRuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewRuntimeOptionsManagerRegistry() RuntimeOptionsManagerRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewRuntimeOptionsManagerRegistry returns a new runtime options manager registry.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SchemaDescr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SchemaDescr interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// DeployId returns the deploy id of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	DeployId() string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// PrevDeployId returns the previous deploy id of the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	PrevDeployId() string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Get returns the message descriptor for the schema.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Get() MessageDescriptor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// String returns the compact text of the message descriptor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	String() string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Equal returns true if the provided value is equal to this one.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Equal(SchemaDescr) bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SchemaDescr describes the schema for a complex type value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetTestSchemaDescr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetTestSchemaDescr(md *desc.MessageDescriptor) SchemaDescr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetTestSchemaDescrWithDeployID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetTestSchemaDescrWithDeployID(md *desc.MessageDescriptor, deployID string) SchemaDescr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SchemaHistory interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Equal returns true if the provided value is equal to this one.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Equal(SchemaHistory) bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Extends returns true iif the provided value has a lineage to this one.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Extends(SchemaHistory) bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Get gets the schema descriptor for the specified deploy id.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Get(id string) (SchemaDescr, bool)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// GetLatest gets the latest version of schema descriptor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	GetLatest() (SchemaDescr, bool)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SchemaHistory represents schema history for a namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func LoadSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func LoadSchemaHistory(options *nsproto.SchemaOptions) (SchemaHistory, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LoadSchemaHistory loads schema registry from SchemaOptions proto.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSchemaHistory() SchemaHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewSchemaHistory returns an empty schema history.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaListener interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// SetSchemaHistory is called when the listener is registered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// and when any updates occurred passing the new schema history.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SetSchemaHistory(value SchemaHistory)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SchemaListener listens for updates to schema registry for a namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaRegistry interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GetLatestSchema gets the latest schema for the namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If proto is not enabled, nil, nil is returned.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GetLatestSchema(id ident.ID) (SchemaDescr, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GetSchema gets the latest schema for the namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If proto is not enabled, nil, nil is returned.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GetSchema(id ident.ID, schemaID string) (SchemaDescr, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// SetSchemaHistory sets the schema history for the namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If proto is not enabled, nil is returned.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetSchemaHistory(id ident.ID, history SchemaHistory) error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// RegisterListener registers a schema listener for the namespace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If proto is not enabled, nil, nil is returned
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	RegisterListener(id ident.ID, listener SchemaListener) (xresource.SimpleCloser, error)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Close closes all the listeners.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Close()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SchemaRegistry represents the schema registry for a database. It is where dynamic schema updates are delivered into, and where schema is retrieved from at series read and write path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewSchemaRegistry(protoEnabled bool, logger *zap.Logger) SchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type StagingState

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            StagingState is the state associated with a namespace's availability for reads and writes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewStagingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewStagingState(status nsproto.StagingStatus) (StagingState, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewStagingState creates a new StagingState.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ToStagingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ToStagingState(state *nsproto.StagingState) (StagingState, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ToStagingState converts nsproto.StagingState to StagingState.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (StagingState) Status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s StagingState) Status() StagingStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Status returns the StagingStatus for a namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (StagingState) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s StagingState) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Validate validates the StagingState object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StagingStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StagingStatus uint8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      StagingStatus is the status of the namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// UnknownStagingStatus represents an unknown staging status.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Namespaces created before StagingState was added to the namespace API
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// will return UnknownStagingStatus. Callers should be prepared to handle this case.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	UnknownStagingStatus StagingStatus = iota
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// InitializingStagingStatus means the namespace is in the process of coming online for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	InitializingStagingStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// ReadyStagingStatus means the namespace is ready for use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ReadyStagingStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (StagingStatus) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s StagingStatus) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Watch interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// C is the notification channel for when a value becomes available.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	C() <-chan struct{}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Get the current namespace map.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Get() Map
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Close closes the watch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Close() error
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Watch is a watch on a namespace Map.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewWatch(w xwatch.Watch) Watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewWatch creates a new watch on a topology map from a generic watch that watches a Map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Package kvadmin is a generated GoMock package.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Package kvadmin is a generated GoMock package.