indexer

type AdminManager interface {
}

type BucketFlushEnabledMap map[string]bool

type BucketFlushInProgressMap map[string]bool

type BucketHWTMap map[string]Timestamp

type BucketIndexCountMap map[string]int

type BucketLastTsFlushedMap map[string]Timestamp

type BucketNewTsReqdMap map[string]bool

type BucketQueueMap map[string]IndexerMutationQueue

type BucketStopChMap map[string]StopChannel

type BucketSyncCountMap map[string]uint64

type BucketTsListMap map[string]*list.List

type CbqBridge interface {
}

type ClustMgrSender interface {
}

type Counter interface {
	CountTotal(stopch StopChannel) (uint64, error)
}

type DoneChannel chan bool

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

type Exister interface {
	Exists(key Key, stopch StopChannel) (bool, error)
}

type Flusher interface {

	//PersistUptoTS will flush the mutation queue upto Timestamp provided.
	//Can be stopped anytime by closing StopChannel.
	//Sends SUCCESS on the MsgChannel when its done flushing till TS.
	//Any error condition is reported back on the MsgChannel.
	//Caller can wait on MsgChannel after closing StopChannel
	//to get notified about shutdown completion.
	PersistUptoTS(q MutationQueue, streamId common.StreamId, indexInstMap common.IndexInstMap,
		indexPartnMap IndexPartnMap, ts Timestamp, stopch StopChannel) MsgChannel

	//DrainUptoTS will flush the mutation queue upto Timestamp
	//provided without actually persisting it.
	//Can be stopped anytime by closing the StopChannel.
	//Sends SUCCESS on the MsgChannel when its done flushing till timestamp.
	//Any error condition is reported back on the MsgChannel.
	//Caller can wait on MsgChannel after closing StopChannel
	//to get notified about shutdown completion.
	DrainUptoTS(q MutationQueue, streamId common.StreamId, ts Timestamp,
		stopch StopChannel) MsgChannel

	//Persist will keep flushing the mutation queue till caller closes
	//the stop channel.Can be stopped anytime by closing the StopChannel.
	//Any error condition is reported back on the MsgChannel.
	//Caller can wait on MsgChannel after closing StopChannel to get
	//notified about shutdown completion.
	Persist(q MutationQueue, streamId common.StreamId, indexInstMap common.IndexInstMap,
		indexPartnMap IndexPartnMap, stopch StopChannel) MsgChannel

	//Drain will keep flushing the mutation queue till caller closes
	//the stop channel without actually persisting the mutations.
	//Can be stopped anytime by closing the StopChannel.
	//Any error condition is reported back on the MsgChannel.
	//Caller can wait on MsgChannel after closing StopChannel to get
	//notified about shutdown completion.
	Drain(q MutationQueue, streamId common.StreamId, stopch StopChannel) MsgChannel

	//IsTimestampGreaterThanQueueLWT checks if each Vbucket in the Queue
	//has mutation with Seqno lower than the corresponding Seqno present
	//in the specified timestamp.
	IsQueueLWTLowerThanTimestamp(q MutationQueue, ts Timestamp) bool

	//GetQueueLWT returns the lowest seqno for each vbucket in the queue
	GetQueueLWT(q MutationQueue) Timestamp

	//GetQueueHWT returns the highest seqno for each vbucket in the queue
	GetQueueHWT(q MutationQueue) Timestamp
}

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

type HashedSliceContainer struct {
	SliceMap  map[SliceId]Slice
	NumSlices int
}

type Inclusion int

type IndexError struct {
	Code string `json:"code,omitempty"`
	Msg  string `json:"msg,omitempty"`
}

type IndexInfo struct {
	Name       string           `json:"name,omitempty"`       // Name of the index
	Uuid       string           `json:"uuid,omitempty"`       // unique id for every index
	Using      common.IndexType `json:"using,omitempty"`      // indexing algorithm
	OnExprList []string         `json:"onExprList,omitempty"` // expression list
	Bucket     string           `json:"bucket,omitempty"`     // bucket name
	IsPrimary  bool             `json:"isPrimary,omitempty"`
	Exprtype   common.ExprType  `json:"exprType,omitempty"`
}

type IndexMetaResponse struct {
	Status     ResponseStatus `json:"status,omitempty"`
	Indexes    []IndexInfo    `json:"indexes,omitempty"`
	ServerUuid string         `json:"serverUuid,omitempty"`
	Nodes      []NodeInfo     `json:"nodes,omitempty"`
	Errors     []IndexError   `json:"errors,omitempty"`
}

type IndexPartnMap map[common.IndexInstId]PartitionInstMap

type IndexQueueMap map[common.IndexInstId]IndexerMutationQueue

type IndexReader interface {
	Counter
	Ranger
	RangeCounter
}

type IndexRequest struct {
	Type       RequestType `json:"type,omitempty"`
	Index      IndexInfo   `json:"index,omitempty"`
	ServerUuid string      `json:"serverUuid,omitempty"`
	Params     QueryParams `json:"params,omitempty"`
}

type IndexRow struct {
	Key   [][]byte `json:"key,omitempty"`
	Value string   `json:"value,omitempty"`
}

type IndexScanResponse struct {
	Status    ResponseStatus `json:"status,omitempty"`
	TotalRows uint64         `json:"totalrows,omitempty"`
	Rows      []IndexRow     `json:"rows,omitempty"`
	Errors    []IndexError   `json:"errors,omitempty"`
}

type IndexWriter interface {

	//Persist a key/value pair
	Insert(key Key, value Value) error

	//Delete a key/value pair by docId
	Delete(docid []byte) error

	//Commit the pending operations
	Commit() error

	//Snapshot
	Snapshot() (Snapshot, error)

	//Close the index. Should be able to reopen after this operation
	Close() error

	//Destroy/Wipe the index completely
	Destroy() error
}

type Indexer interface {
	Shutdown() Message
}

type IndexerId uint64

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

type IndexerState int16

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

type KVSender interface {
}

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

type Keybytes [][]byte

type Looker interface {
	Exister
	Lookup(key Key, stopch StopChannel) (chan Value, chan error)
	KeySet(stop StopChannel) (chan Key, chan error)
	ValueSet(stop StopChannel) (chan Value, chan error)
}

type Message interface {
	GetMsgType() MsgType
}

type MsgChannel chan Message

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

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

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

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

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

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

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

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

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

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

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

type MsgSuccess struct {
}

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

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

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

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

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

type MsgType int16

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

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

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

type MutationChannel chan *MutationKeys

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

type MutationManager interface {
}

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

type MutationQueue interface {

	//enqueue a mutation reference based on vbucket
	Enqueue(mutation *MutationKeys, vbucket Vbucket) error

	//dequeue a vbucket's mutation and keep sending on a channel until stop signal
	Dequeue(vbucket Vbucket) (<-chan *MutationKeys, chan<- bool, error)
	//dequeue a vbucket's mutation upto seqno(wait if not available)
	DequeueUptoSeqno(vbucket Vbucket, seqno Seqno) (<-chan *MutationKeys, error)
	//dequeue single element for a vbucket and return
	DequeueSingleElement(vbucket Vbucket) *MutationKeys

	//return reference to a vbucket's mutation at Tail of queue without dequeue
	PeekTail(vbucket Vbucket) *MutationKeys
	//return reference to a vbucket's mutation at Head of queue without dequeue
	PeekHead(vbucket Vbucket) *MutationKeys

	//return size of queue per vbucket
	GetSize(vbucket Vbucket) int64

	//returns the numbers of vbuckets for the queue
	GetNumVbuckets() uint16
}

type MutationStreamReader interface {
	Shutdown()
}

type NodeInfo struct {
	IndexerURL string `json:"indexerURL,omitempty"`
}

type PartitionInst struct {
	Defn common.PartitionDefn
	Sc   SliceContainer
}

type PartitionInstMap map[common.PartitionId]PartitionInst

type QueryParams struct {
	ScanType  ScanType  `json:"scanType,omitempty"`
	Low       [][]byte  `json:"low,omitempty"`
	High      [][]byte  `json:"high,omitempty"`
	Inclusion Inclusion `json:"inclusion,omitempty"`
	Limit     int64     `json:"limit,omitempty"`
}

type RangeCounter interface {
	CountRange(low Key, high Key, inclusion Inclusion, stopch StopChannel) (
		uint64, error)
}

type Ranger interface {
	Looker
	KeyRange(low, high Key, inclusion Inclusion, stopch StopChannel) (
		chan Key, chan error, SortOrder)
	ValueRange(low, high Key, inclusion Inclusion, stopch StopChannel) (
		chan Value, chan error, SortOrder)
}

type RequestType string

type ResponseStatus string

type ScanCoordinator interface {
}

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

type ScanType string

type Seqno uint64

type SlabManager interface {
	//AllocBuf allocates a buffer of given size. If returned buffer is nil,
	//Message will have error message
	AllocBuf(bufSize int) ([]byte, Message)

	//ReleaseBuf releases the buffer back to free pool
	ReleaseBuf(buf []byte) bool

	//SetMaxMemoryLimit sets the maximum memory that can be allocated
	SetMaxMemoryLimit(maxMemAlloc uint64) bool

	//GetMaxMemoryLimit returns the maximum memory that can be allocated
	GetMaxMemoryLimit() uint64
}

type Slice interface {
	Id() SliceId
	Name() string
	Status() SliceStatus
	IndexInstId() common.IndexInstId
	IndexDefnId() common.IndexDefnId
	IsActive() bool

	SetActive(bool)
	SetStatus(SliceStatus)

	GetSnapshotContainer() SnapshotContainer

	IndexWriter
}

type SliceContainer interface {
	//Add Slice to container
	AddSlice(SliceId, Slice)

	//Update existing slice
	UpdateSlice(SliceId, Slice)

	//Remove existing slice
	RemoveSlice(SliceId)

	//Return Slice for the given IndexKey
	GetSliceByIndexKey(common.IndexKey) Slice

	//Return SliceId for the given IndexKey
	GetSliceIdByIndexKey(common.IndexKey) SliceId

	//Return Slice for the given SliceId
	GetSliceById(SliceId) Slice

	//Return all Slices
	GetAllSlices() []Slice
}

type SliceId uint64

type SliceStatus int16

type Snapshot interface {
	IndexReader

	Open() error
	Close() error
	IsOpen() bool

	Id() SliceId
	IndexInstId() common.IndexInstId
	IndexDefnId() common.IndexDefnId

	Timestamp() Timestamp
	SetTimestamp(Timestamp)
}

type SnapshotContainer interface {
	Add(Snapshot)
	RemoveOldest() Snapshot
	Len() int

	GetLatestSnapshot() Snapshot
	GetSnapshotEqualToTS(Timestamp) Snapshot
	GetSnapshotRecentThanTS(Timestamp) Snapshot
}

type SortOrder string

type StabilityTimestamp Timestamp

type StopChannel chan bool

type StorageManager interface {
}

type StreamAddressMap map[common.StreamId]common.Endpoint

type StreamStatus map[common.StreamId]bool

type StreamStatusMap map[common.StreamId]bool

type Timekeeper interface {
}

type Timestamp []Seqno

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

type Vbucket uint32

type Vbuuid uint64