kv

type CompactJob interface {
	// Run runs compact logic
	Run() error
}

type Family interface {
	// ID return family's id.
	ID() version.FamilyID
	// Name return family's name.
	Name() string
	// NewFlusher creates flusher for saving data to family.
	NewFlusher() Flusher
	// GetSnapshot returns current version's snapshot.
	GetSnapshot() version.Snapshot
	// Compact compacts all files of level0.
	Compact()
	// contains filtered or unexported methods
}

type FamilyOption struct {
	ID               int    `toml:"id"`
	Name             string `toml:"name"`
	CompactThreshold int    `toml:"compactThreshold"` // level 0 compact threshold
	RollupThreshold  int    `toml:"rollupThreshold"`  // level 0 rollup threshold
	Merger           string `toml:"merger"`           // merger which need implement Merger interface
	MaxFileSize      uint32 `toml:"maxFileSize"`      // max file size
}

type Flusher interface {
	// StreamWriter creates a stream writer for flushing in stream.
	StreamWriter() (table.StreamWriter, error)
	// Add puts k/v pair
	Add(key uint32, value []byte) error
	// Sequence sets write sequence number.
	Sequence(leader int32, seq int64)
	// Commit flushes data and commits metadata.
	Commit() error
	// Release releases the resource of flusher.
	// NOTICE: MUST invoke Release() after new fluster instance.
	Release()
}

type JobScheduler interface {
	// Startup starts the job scheduler.
	Startup()
	// Shutdown stops the job scheduler.
	Shutdown()
	// IsRunning returns the scheduler if running.
	IsRunning() bool
}

type Merger interface {
	// Init initializes merger params or context, before does merge operation
	Init(params map[string]interface{})
	// Merge merges values for same key,
	// merged data will be written into Flusher directly
	// return err if failure
	Merge(key uint32, values [][]byte) error
}

type MergerType string

type NewMerger func(flusher Flusher) (Merger, error)

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

type Rollup interface {
	// GetTimestamp returns the timestamp based on source family and source slot
	GetTimestamp(slot uint16) int64
	// IntervalRatio return interval ratio = target interval/source interval
	IntervalRatio() uint16
	// CalcSlot calculates the target slot based on source timestamp
	CalcSlot(timestamp int64) uint16
	// BaseSlot returns base slot by source family time/target interval.
	BaseSlot() uint16
}

type Store interface {
	// Name returns the store's name.
	Name() string
	// Path returns the store root path.
	Path() string
	// CreateFamily create/load column family.
	CreateFamily(familyName string, option FamilyOption) (Family, error)
	// GetFamily gets family based on name, return nil if not exist.
	GetFamily(familyName string) Family
	// ListFamilyNames returns the all family's name
	ListFamilyNames() []string
	// Option returns the store configuration options
	Option() StoreOption
	// ForceRollup does rollup job manual.
	ForceRollup()
	// contains filtered or unexported methods
}

type StoreManager interface {
	// CreateStore creates the store by name/option.
	// NOTE: name need include relatively path based on root path.
	CreateStore(name string, option StoreOption) (Store, error)
	// GetStoreByName returns Store by given name.
	GetStoreByName(name string) (Store, bool)
	// GetStores returns all Store under manager cache.
	GetStores() []Store
	// CloseStore closes the Store, then remove from manager cache.
	CloseStore(name string) error
}

type StoreOption struct {
	Levels int            `toml:"levels"` // num. of levels
	TTL    ltoml.Duration `toml:"ttl"`

	Source timeutil.Interval   `toml:"source"` // optional(source interval)
	Rollup []timeutil.Interval `toml:"rollup"` // optional(target interval)
}

type StoreOptions struct {
	Dir                  string // store root path
	CompactCheckInterval int    // compact/rollup job check interval(number of seconds)
}