2016-07-03 06:56:49 +00:00
|
|
|
package storage
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"os"
|
|
|
|
|
2019-04-19 04:43:36 +00:00
|
|
|
"github.com/syndtr/goleveldb/leveldb/opt"
|
|
|
|
|
2019-09-12 13:18:21 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/glog"
|
2019-12-18 09:21:21 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/stats"
|
|
|
|
"github.com/chrislusf/seaweedfs/weed/storage/backend"
|
|
|
|
"github.com/chrislusf/seaweedfs/weed/storage/needle"
|
2019-12-23 20:48:20 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/storage/super_block"
|
2019-12-28 20:28:58 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/util"
|
2016-07-03 06:56:49 +00:00
|
|
|
)
|
|
|
|
|
2021-02-07 01:00:03 +00:00
|
|
|
func loadVolumeWithoutIndex(dirname string, collection string, id needle.VolumeId, needleMapKind NeedleMapKind) (v *Volume, err error) {
|
2016-07-03 06:56:49 +00:00
|
|
|
v = &Volume{dir: dirname, Collection: collection, Id: id}
|
2019-12-23 20:48:20 +00:00
|
|
|
v.SuperBlock = super_block.SuperBlock{}
|
2016-07-03 06:56:49 +00:00
|
|
|
v.needleMapKind = needleMapKind
|
2019-12-19 08:44:46 +00:00
|
|
|
err = v.load(false, false, needleMapKind, 0)
|
2016-07-03 06:56:49 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-02-07 01:00:03 +00:00
|
|
|
func (v *Volume) load(alsoLoadIndex bool, createDatIfMissing bool, needleMapKind NeedleMapKind, preallocate int64) (err error) {
|
2018-09-09 09:48:58 +00:00
|
|
|
alreadyHasSuperBlock := false
|
2016-07-03 06:56:49 +00:00
|
|
|
|
2020-12-05 05:50:26 +00:00
|
|
|
hasLoadedVolume := false
|
|
|
|
defer func() {
|
|
|
|
if !hasLoadedVolume {
|
|
|
|
if v.nm != nil {
|
|
|
|
v.nm.Close()
|
|
|
|
v.nm = nil
|
|
|
|
}
|
|
|
|
if v.DataBackend != nil {
|
|
|
|
v.DataBackend.Close()
|
|
|
|
v.DataBackend = nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2020-01-08 17:45:26 +00:00
|
|
|
hasVolumeInfoFile := v.maybeLoadVolumeInfo() && v.volumeInfo.Version != 0
|
2019-12-28 19:35:27 +00:00
|
|
|
|
|
|
|
if v.HasRemoteFile() {
|
2019-12-19 08:42:46 +00:00
|
|
|
v.noWriteCanDelete = true
|
2019-12-28 19:35:27 +00:00
|
|
|
v.noWriteOrDelete = false
|
|
|
|
glog.V(0).Infof("loading volume %d from remote %v", v.Id, v.volumeInfo.Files)
|
|
|
|
v.LoadRemoteFile()
|
2019-12-02 23:08:28 +00:00
|
|
|
alreadyHasSuperBlock = true
|
2020-11-27 11:17:10 +00:00
|
|
|
} else if exists, canRead, canWrite, modifiedTime, fileSize := util.CheckFile(v.FileName(".dat")); exists {
|
2019-12-02 23:08:28 +00:00
|
|
|
// open dat file
|
2016-07-03 06:56:49 +00:00
|
|
|
if !canRead {
|
2020-11-27 11:17:10 +00:00
|
|
|
return fmt.Errorf("cannot read Volume Data file %s", v.FileName(".dat"))
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
2019-11-09 08:10:59 +00:00
|
|
|
var dataFile *os.File
|
2016-07-03 06:56:49 +00:00
|
|
|
if canWrite {
|
2020-11-27 11:17:10 +00:00
|
|
|
dataFile, err = os.OpenFile(v.FileName(".dat"), os.O_RDWR|os.O_CREATE, 0644)
|
2016-07-03 06:56:49 +00:00
|
|
|
} else {
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(0).Infof("opening %s in READONLY mode", v.FileName(".dat"))
|
|
|
|
dataFile, err = os.Open(v.FileName(".dat"))
|
2019-12-19 08:42:46 +00:00
|
|
|
v.noWriteOrDelete = true
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
2019-08-21 03:26:01 +00:00
|
|
|
v.lastModifiedTsSeconds = uint64(modifiedTime.Unix())
|
2019-12-23 20:48:20 +00:00
|
|
|
if fileSize >= super_block.SuperBlockSize {
|
2018-09-09 09:48:58 +00:00
|
|
|
alreadyHasSuperBlock = true
|
|
|
|
}
|
2019-11-09 08:10:59 +00:00
|
|
|
v.DataBackend = backend.NewDiskFile(dataFile)
|
2016-07-03 06:56:49 +00:00
|
|
|
} else {
|
|
|
|
if createDatIfMissing {
|
2020-11-27 11:17:10 +00:00
|
|
|
v.DataBackend, err = backend.CreateVolumeFile(v.FileName(".dat"), preallocate, v.MemoryMapMaxSizeMb)
|
2016-07-03 06:56:49 +00:00
|
|
|
} else {
|
2020-11-27 11:17:10 +00:00
|
|
|
return fmt.Errorf("volume data file %s does not exist", v.FileName(".dat"))
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-19 08:44:46 +00:00
|
|
|
if err != nil {
|
|
|
|
if !os.IsPermission(err) {
|
2020-11-27 11:17:10 +00:00
|
|
|
return fmt.Errorf("cannot load volume data %s: %v", v.FileName(".dat"), err)
|
2018-07-10 06:31:25 +00:00
|
|
|
} else {
|
2020-11-27 11:17:10 +00:00
|
|
|
return fmt.Errorf("load data file %s: %v", v.FileName(".dat"), err)
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-09 09:48:58 +00:00
|
|
|
if alreadyHasSuperBlock {
|
2019-12-19 08:44:46 +00:00
|
|
|
err = v.readSuperBlock()
|
2016-07-03 06:56:49 +00:00
|
|
|
} else {
|
2019-10-09 07:02:50 +00:00
|
|
|
if !v.SuperBlock.Initialized() {
|
2020-11-27 11:17:10 +00:00
|
|
|
return fmt.Errorf("volume %s not initialized", v.FileName(".dat"))
|
2019-10-09 07:02:50 +00:00
|
|
|
}
|
2019-12-19 08:44:46 +00:00
|
|
|
err = v.maybeWriteSuperBlock()
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
2019-12-19 08:44:46 +00:00
|
|
|
if err == nil && alsoLoadIndex {
|
2020-11-27 11:17:10 +00:00
|
|
|
// adjust for existing volumes with .idx together with .dat files
|
|
|
|
if v.dirIdx != v.dir {
|
2020-12-22 10:34:08 +00:00
|
|
|
if util.FileExists(v.DataFileName() + ".idx") {
|
2020-11-27 11:17:10 +00:00
|
|
|
v.dirIdx = v.dir
|
|
|
|
}
|
|
|
|
}
|
2016-07-03 06:56:49 +00:00
|
|
|
var indexFile *os.File
|
2019-12-19 08:42:46 +00:00
|
|
|
if v.noWriteOrDelete {
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(0).Infoln("open to read file", v.FileName(".idx"))
|
|
|
|
if indexFile, err = os.OpenFile(v.FileName(".idx"), os.O_RDONLY, 0644); err != nil {
|
2020-12-22 10:34:08 +00:00
|
|
|
return fmt.Errorf("cannot read Volume Index %s: %v", v.FileName(".idx"), err)
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
|
|
|
} else {
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(1).Infoln("open to write file", v.FileName(".idx"))
|
|
|
|
if indexFile, err = os.OpenFile(v.FileName(".idx"), os.O_RDWR|os.O_CREATE, 0644); err != nil {
|
2020-12-22 10:34:08 +00:00
|
|
|
return fmt.Errorf("cannot write Volume Index %s: %v", v.FileName(".idx"), err)
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
|
|
|
}
|
2020-10-28 08:14:39 +00:00
|
|
|
if v.lastAppendAtNs, err = CheckAndFixVolumeDataIntegrity(v, indexFile); err != nil {
|
2019-12-19 08:42:46 +00:00
|
|
|
v.noWriteOrDelete = true
|
2019-12-19 08:44:46 +00:00
|
|
|
glog.V(0).Infof("volumeDataIntegrityChecking failed %v", err)
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
2019-12-18 09:21:21 +00:00
|
|
|
|
2020-07-03 23:34:31 +00:00
|
|
|
if v.noWriteOrDelete || v.noWriteCanDelete {
|
2020-11-27 11:17:10 +00:00
|
|
|
if v.nm, err = NewSortedFileNeedleMap(v.IndexFileName(), indexFile); err != nil {
|
2020-12-22 10:34:08 +00:00
|
|
|
glog.V(0).Infof("loading sorted db %s error: %v", v.FileName(".sdx"), err)
|
2019-04-09 16:42:06 +00:00
|
|
|
}
|
2019-12-18 09:21:21 +00:00
|
|
|
} else {
|
|
|
|
switch needleMapKind {
|
|
|
|
case NeedleMapInMemory:
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(0).Infoln("loading index", v.FileName(".idx"), "to memory")
|
2019-12-19 08:44:46 +00:00
|
|
|
if v.nm, err = LoadCompactNeedleMap(indexFile); err != nil {
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(0).Infof("loading index %s to memory error: %v", v.FileName(".idx"), err)
|
2019-12-18 09:21:21 +00:00
|
|
|
}
|
|
|
|
case NeedleMapLevelDb:
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(0).Infoln("loading leveldb", v.FileName(".ldb"))
|
2019-12-18 09:21:21 +00:00
|
|
|
opts := &opt.Options{
|
|
|
|
BlockCacheCapacity: 2 * 1024 * 1024, // default value is 8MiB
|
|
|
|
WriteBuffer: 1 * 1024 * 1024, // default value is 4MiB
|
|
|
|
CompactionTableSizeMultiplier: 10, // default value is 1
|
|
|
|
}
|
2020-11-27 11:17:10 +00:00
|
|
|
if v.nm, err = NewLevelDbNeedleMap(v.FileName(".ldb"), indexFile, opts); err != nil {
|
|
|
|
glog.V(0).Infof("loading leveldb %s error: %v", v.FileName(".ldb"), err)
|
2019-12-18 09:21:21 +00:00
|
|
|
}
|
|
|
|
case NeedleMapLevelDbMedium:
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(0).Infoln("loading leveldb medium", v.FileName(".ldb"))
|
2019-12-18 09:21:21 +00:00
|
|
|
opts := &opt.Options{
|
|
|
|
BlockCacheCapacity: 4 * 1024 * 1024, // default value is 8MiB
|
|
|
|
WriteBuffer: 2 * 1024 * 1024, // default value is 4MiB
|
|
|
|
CompactionTableSizeMultiplier: 10, // default value is 1
|
|
|
|
}
|
2020-11-27 11:17:10 +00:00
|
|
|
if v.nm, err = NewLevelDbNeedleMap(v.FileName(".ldb"), indexFile, opts); err != nil {
|
|
|
|
glog.V(0).Infof("loading leveldb %s error: %v", v.FileName(".ldb"), err)
|
2019-12-18 09:21:21 +00:00
|
|
|
}
|
|
|
|
case NeedleMapLevelDbLarge:
|
2020-11-27 11:17:10 +00:00
|
|
|
glog.V(0).Infoln("loading leveldb large", v.FileName(".ldb"))
|
2019-12-18 09:21:21 +00:00
|
|
|
opts := &opt.Options{
|
|
|
|
BlockCacheCapacity: 8 * 1024 * 1024, // default value is 8MiB
|
|
|
|
WriteBuffer: 4 * 1024 * 1024, // default value is 4MiB
|
|
|
|
CompactionTableSizeMultiplier: 10, // default value is 1
|
|
|
|
}
|
2020-11-27 11:17:10 +00:00
|
|
|
if v.nm, err = NewLevelDbNeedleMap(v.FileName(".ldb"), indexFile, opts); err != nil {
|
|
|
|
glog.V(0).Infof("loading leveldb %s error: %v", v.FileName(".ldb"), err)
|
2019-12-18 09:21:21 +00:00
|
|
|
}
|
2017-05-27 05:51:25 +00:00
|
|
|
}
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|
|
|
|
}
|
2017-01-06 18:22:20 +00:00
|
|
|
|
2020-01-08 17:45:26 +00:00
|
|
|
if !hasVolumeInfoFile {
|
|
|
|
v.volumeInfo.Version = uint32(v.SuperBlock.Version)
|
|
|
|
v.SaveVolumeInfo()
|
|
|
|
}
|
|
|
|
|
2019-06-18 04:02:50 +00:00
|
|
|
stats.VolumeServerVolumeCounter.WithLabelValues(v.Collection, "volume").Inc()
|
2019-06-16 09:24:15 +00:00
|
|
|
|
2020-12-05 05:50:26 +00:00
|
|
|
if err == nil {
|
|
|
|
hasLoadedVolume = true
|
|
|
|
}
|
|
|
|
|
2019-12-19 08:44:46 +00:00
|
|
|
return err
|
2016-07-03 06:56:49 +00:00
|
|
|
}
|