options.go

// Copyright 2021 The Bitalosdb author(hustxrb@163.com) and other contributors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package bitalosdb

import (
	"time"

	"github.com/zuoyebang/bitalosdb/internal/base"
	"github.com/zuoyebang/bitalosdb/internal/compress"
	"github.com/zuoyebang/bitalosdb/internal/consts"
	"github.com/zuoyebang/bitalosdb/internal/vfs"
)

type IterOptions = base.IterOptions

type WriteOptions struct {
	Sync bool
}

var Sync = &WriteOptions{Sync: true}

var NoSync = &WriteOptions{Sync: false}

func (o *WriteOptions) GetSync() bool {
	return o == nil || o.Sync
}

type CompactEnv struct {
	StartHour     int
	EndHour       int
	DeletePercent float64
	BitreeMaxSize int64
	Interval      int
}

type BitableOptions = base.BitableOptions

type Options struct {
	BytesPerSync                int
	Comparer                    *Comparer
	DisableWAL                  bool
	EventListener               EventListener
	MemTableSize                int
	MemTableStopWritesThreshold int
	ReadOnly                    bool
	WALBytesPerSync             int
	WALDir                      string
	WALMinSyncInterval          func() time.Duration
	FS                          vfs.FS
	Logger                      Logger
	Id                          int
	Verbose                     bool
	LogTag                      string
	DataType                    string
	CompressionType             int
	DeleteFileInternal          int
	UseBithash                  bool
	UseBitable                  bool
	BitableOpts                 *base.BitableOptions
	AutoCompact                 bool
	CompactInfo                 CompactEnv
	CacheSize                   int64
	CacheType                   int
	CacheShards                 int
	CacheHashSize               int
	UseMapIndex                 bool
	UsePrefixCompress           bool
	UseBlockCompress            bool
	FlushReporter               func(int)
	KeyHashFunc                 func(k []byte) int
	KvCheckExpireFunc           func(int, []byte, []byte) bool
	KvTimestampFunc             func([]byte, uint8) (bool, uint64)
	IOWriteLoadThresholdFunc    func() bool
	private                     struct {
		logInit bool
	}
}

func (o *Options) ensureOptionsPool() *base.OptionsPool {
	optspool := base.InitDefaultsOptionsPool()

	optspool.BaseOptions.Id = o.Id
	optspool.BaseOptions.FS = o.FS
	optspool.BaseOptions.Cmp = o.Comparer.Compare
	optspool.BaseOptions.Logger = o.Logger
	optspool.BaseOptions.BytesPerSync = o.BytesPerSync
	optspool.BaseOptions.Compressor = compress.SetCompressor(o.CompressionType)
	optspool.BaseOptions.UseBithash = o.UseBithash
	optspool.BaseOptions.UseBitable = o.UseBitable
	optspool.BaseOptions.UseMapIndex = o.UseMapIndex
	optspool.BaseOptions.UsePrefixCompress = o.UsePrefixCompress
	optspool.BaseOptions.UseBlockCompress = o.UseBlockCompress
	if o.KeyHashFunc != nil {
		optspool.BaseOptions.KeyHashFunc = o.KeyHashFunc
	}
	if o.KvCheckExpireFunc != nil {
		optspool.BaseOptions.KvCheckExpireFunc = o.KvCheckExpireFunc
	}
	if o.KvTimestampFunc != nil {
		optspool.BaseOptions.KvTimestampFunc = o.KvTimestampFunc
	}

	if o.UseBitable {
		o.BitableOpts.Options = optspool.BaseOptions
		optspool.BitableOptions = o.BitableOpts
	}

	dflOpts := &base.DFLOption{
		Logger:         o.Logger,
		DeleteInterval: o.DeleteFileInternal,
	}
	if o.IOWriteLoadThresholdFunc != nil {
		dflOpts.IOWriteLoadThresholdCB = o.IOWriteLoadThresholdFunc
	} else {
		dflOpts.IOWriteLoadThresholdCB = base.DefaultIOWriteLoadThresholdFunc
	}
	optspool.BaseOptions.DeleteFilePacer.Run(dflOpts)

	return optspool
}

func (o *Options) EnsureDefaults() *Options {
	if o == nil {
		o = &Options{}
	}
	if o.BytesPerSync <= 0 {
		o.BytesPerSync = consts.DefaultBytesPerSync
	}
	if o.Comparer == nil {
		o.Comparer = DefaultComparer
	}
	if o.MemTableSize <= 0 {
		o.MemTableSize = consts.DefaultMemTableSize
	}
	if o.MemTableStopWritesThreshold <= 0 {
		o.MemTableStopWritesThreshold = consts.DefaultMemTableStopWritesThreshold
	}
	if o.CacheSize <= 0 {
		o.CacheSize = 0
	} else if o.CacheSize > 0 {
		if o.CacheSize < consts.DefaultCacheSize {
			o.CacheSize = consts.DefaultCacheSize
		}
		if o.CacheType <= 0 || o.CacheType > consts.CacheTypeLfu {
			o.CacheType = consts.CacheTypeLfu
		}
		if o.CacheType == consts.CacheTypeLfu {
			o.CacheShards = consts.DefaultLfuCacheShards
		} else {
			o.CacheShards = consts.DefaultLruCacheShards
			if o.CacheHashSize <= 0 {
				o.CacheHashSize = consts.DefaultLruCacheHashSize
			}
		}
	}
	if o.DeleteFileInternal == 0 {
		o.DeleteFileInternal = consts.DeletionFileInterval
	}

	if !o.private.logInit {
		o.Logger = base.NewLogger(o.Logger, o.LogTag)
		if o.Verbose {
			o.EventListener = MakeLoggingEventListener(o.Logger)
		} else {
			o.EventListener.EnsureDefaults(o.Logger)
		}
		o.private.logInit = true
	}

	if o.FS == nil {
		o.FS = vfs.WithDiskHealthChecks(vfs.Default, 5*time.Second,
			func(name string, duration time.Duration) {
				o.EventListener.DiskSlow(DiskSlowInfo{
					Path:     name,
					Duration: duration,
				})
			})
	}

	if o.CompactInfo.StartHour <= 0 {
		o.CompactInfo.StartHour = 0
	}
	if o.CompactInfo.EndHour <= 0 {
		o.CompactInfo.EndHour = 23
	}
	if o.CompactInfo.EndHour <= o.CompactInfo.StartHour {
		o.CompactInfo.EndHour = o.CompactInfo.StartHour + 1
	}
	if o.CompactInfo.EndHour > 23 {
		o.CompactInfo.EndHour = 23
	}
	if o.CompactInfo.DeletePercent < 0 || o.CompactInfo.DeletePercent >= 1 {
		o.CompactInfo.DeletePercent = consts.DefaultDeletePercent
	}
	if o.CompactInfo.BitreeMaxSize <= 0 {
		o.CompactInfo.BitreeMaxSize = consts.UseBitableBitreeMaxSize
	}
	if o.CompactInfo.Interval == 0 {
		o.CompactInfo.Interval = consts.DefaultCompactInterval
	}
	if o.CompactInfo.Interval < consts.MinCompactInterval {
		o.CompactInfo.Interval = consts.MinCompactInterval
	}

	if o.UseBitable {
		o.BitableOpts = base.DefaultBitableOptions
	}

	if o.IOWriteLoadThresholdFunc == nil {
		o.IOWriteLoadThresholdFunc = base.DefaultIOWriteLoadThresholdFunc
	}

	return o
}

func (o *Options) Clone() *Options {
	n := &Options{}
	if o != nil {
		*n = *o
	}
	return n
}