From e28c991331d5039ee59759a8c41b6deef89191b3 Mon Sep 17 00:00:00 2001 From: Jakob Borg Date: Wed, 28 Oct 2015 21:01:46 +0100 Subject: [PATCH] Create an instance type to tie database methods to --- lib/db/leveldb.go | 30 +++++++++++++++++------------- lib/db/set.go | 38 ++++++++++++++++++++------------------ 2 files changed, 37 insertions(+), 31 deletions(-) diff --git a/lib/db/leveldb.go b/lib/db/leveldb.go index 159069e4e..e41e60d62 100644 --- a/lib/db/leveldb.go +++ b/lib/db/leveldb.go @@ -94,6 +94,10 @@ type dbWriter interface { Delete([]byte) } +type dbInstance struct { + *leveldb.DB +} + // Flush batches to disk when they contain this many records. const batchFlushSize = 64 @@ -168,7 +172,7 @@ func globalKeyFolder(key []byte) []byte { type deletionHandler func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) int64 -func ldbGenericReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker, deleteFn deletionHandler) int64 { +func (db *dbInstance) genericReplace(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker, deleteFn deletionHandler) int64 { sort.Sort(fileList(fs)) // sort list on name, same as in the database start := deviceKey(folder, device, nil) // before all folder/device files @@ -290,9 +294,9 @@ func ldbGenericReplace(db *leveldb.DB, folder, device []byte, fs []protocol.File return maxLocalVer } -func ldbReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker) int64 { +func (db *dbInstance) replace(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker) int64 { // TODO: Return the remaining maxLocalVer? - return ldbGenericReplace(db, folder, device, fs, localSize, globalSize, func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) int64 { + return db.genericReplace(folder, device, fs, localSize, globalSize, func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) int64 { // Database has a file that we are missing. Remove it. l.Debugf("delete; folder=%q device=%v name=%q", folder, protocol.DeviceIDFromBytes(device), name) ldbRemoveFromGlobal(db, batch, folder, device, name, globalSize) @@ -302,7 +306,7 @@ func ldbReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, l }) } -func ldbUpdate(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker) int64 { +func (db *dbInstance) update(folder, device []byte, fs []protocol.FileInfo, localSize, globalSize *sizeTracker) int64 { batch := new(leveldb.Batch) l.Debugf("new batch %p", batch) snap, err := db.GetSnapshot() @@ -568,7 +572,7 @@ func ldbRemoveFromGlobal(db dbReader, batch dbWriter, folder, device, file []byt } } -func ldbWithHave(db *leveldb.DB, folder, device []byte, truncate bool, fn Iterator) { +func (db *dbInstance) withHave(folder, device []byte, truncate bool, fn Iterator) { start := deviceKey(folder, device, nil) // before all folder/device files limit := deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files snap, err := db.GetSnapshot() @@ -595,7 +599,7 @@ func ldbWithHave(db *leveldb.DB, folder, device []byte, truncate bool, fn Iterat } } -func ldbWithAllFolderTruncated(db *leveldb.DB, folder []byte, fn func(device []byte, f FileInfoTruncated) bool) { +func (db *dbInstance) withAllFolderTruncated(folder []byte, fn func(device []byte, f FileInfoTruncated) bool) { start := deviceKey(folder, nil, nil) // before all folder/device files limit := deviceKey(folder, protocol.LocalDeviceID[:], []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files snap, err := db.GetSnapshot() @@ -653,7 +657,7 @@ func ldbGet(db dbReader, folder, device, file []byte) (protocol.FileInfo, bool) return f, true } -func ldbGetGlobal(db *leveldb.DB, folder, file []byte, truncate bool) (FileIntf, bool) { +func (db *dbInstance) getGlobal(folder, file []byte, truncate bool) (FileIntf, bool) { k := globalKey(folder, file) snap, err := db.GetSnapshot() if err != nil { @@ -698,7 +702,7 @@ func ldbGetGlobal(db *leveldb.DB, folder, file []byte, truncate bool) (FileIntf, return fi, true } -func ldbWithGlobal(db *leveldb.DB, folder, prefix []byte, truncate bool, fn Iterator) { +func (db *dbInstance) withGlobal(folder, prefix []byte, truncate bool, fn Iterator) { snap, err := db.GetSnapshot() if err != nil { panic(err) @@ -749,7 +753,7 @@ func ldbWithGlobal(db *leveldb.DB, folder, prefix []byte, truncate bool, fn Iter } } -func ldbAvailability(db *leveldb.DB, folder, file []byte) []protocol.DeviceID { +func (db *dbInstance) availability(folder, file []byte) []protocol.DeviceID { k := globalKey(folder, file) bs, err := db.Get(k, nil) if err == leveldb.ErrNotFound { @@ -777,7 +781,7 @@ func ldbAvailability(db *leveldb.DB, folder, file []byte) []protocol.DeviceID { return devices } -func ldbWithNeed(db *leveldb.DB, folder, device []byte, truncate bool, fn Iterator) { +func (db *dbInstance) withNeed(folder, device []byte, truncate bool, fn Iterator) { start := globalKey(folder, nil) limit := globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff}) snap, err := db.GetSnapshot() @@ -875,7 +879,7 @@ nextFile: } } -func ldbListFolders(db *leveldb.DB) []string { +func (db *dbInstance) listFolders() []string { snap, err := db.GetSnapshot() if err != nil { panic(err) @@ -906,7 +910,7 @@ func ldbListFolders(db *leveldb.DB) []string { return folders } -func ldbDropFolder(db *leveldb.DB, folder []byte) { +func (db *dbInstance) dropFolder(folder []byte) { snap, err := db.GetSnapshot() if err != nil { panic(err) @@ -950,7 +954,7 @@ func unmarshalTrunc(bs []byte, truncate bool) (FileIntf, error) { return tf, err } -func ldbCheckGlobals(db *leveldb.DB, folder []byte, globalSize *sizeTracker) { +func (db *dbInstance) checkGlobals(folder []byte, globalSize *sizeTracker) { snap, err := db.GetSnapshot() if err != nil { panic(err) diff --git a/lib/db/set.go b/lib/db/set.go index bdc4e33d3..2ae606c1d 100644 --- a/lib/db/set.go +++ b/lib/db/set.go @@ -25,7 +25,7 @@ type FileSet struct { localVersion map[protocol.DeviceID]int64 mutex sync.Mutex folder string - db *leveldb.DB + db *dbInstance blockmap *BlockMap localSize sizeTracker globalSize sizeTracker @@ -97,15 +97,15 @@ func NewFileSet(folder string, db *leveldb.DB) *FileSet { var s = FileSet{ localVersion: make(map[protocol.DeviceID]int64), folder: folder, - db: db, + db: &dbInstance{db}, blockmap: NewBlockMap(db, folder), mutex: sync.NewMutex(), } - ldbCheckGlobals(db, []byte(folder), &s.globalSize) + s.db.checkGlobals([]byte(folder), &s.globalSize) var deviceID protocol.DeviceID - ldbWithAllFolderTruncated(db, []byte(folder), func(device []byte, f FileInfoTruncated) bool { + s.db.withAllFolderTruncated([]byte(folder), func(device []byte, f FileInfoTruncated) bool { copy(deviceID[:], device) if f.LocalVersion > s.localVersion[deviceID] { s.localVersion[deviceID] = f.LocalVersion @@ -126,7 +126,7 @@ func (s *FileSet) Replace(device protocol.DeviceID, fs []protocol.FileInfo) { normalizeFilenames(fs) s.mutex.Lock() defer s.mutex.Unlock() - s.localVersion[device] = ldbReplace(s.db, []byte(s.folder), device[:], fs, &s.localSize, &s.globalSize) + s.localVersion[device] = s.db.replace([]byte(s.folder), device[:], fs, &s.localSize, &s.globalSize) if len(fs) == 0 { // Reset the local version if all files were removed. s.localVersion[device] = 0 @@ -155,44 +155,44 @@ func (s *FileSet) Update(device protocol.DeviceID, fs []protocol.FileInfo) { s.blockmap.Discard(discards) s.blockmap.Update(updates) } - if lv := ldbUpdate(s.db, []byte(s.folder), device[:], fs, &s.localSize, &s.globalSize); lv > s.localVersion[device] { + if lv := s.db.update([]byte(s.folder), device[:], fs, &s.localSize, &s.globalSize); lv > s.localVersion[device] { s.localVersion[device] = lv } } func (s *FileSet) WithNeed(device protocol.DeviceID, fn Iterator) { l.Debugf("%s WithNeed(%v)", s.folder, device) - ldbWithNeed(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn)) + s.db.withNeed([]byte(s.folder), device[:], false, nativeFileIterator(fn)) } func (s *FileSet) WithNeedTruncated(device protocol.DeviceID, fn Iterator) { l.Debugf("%s WithNeedTruncated(%v)", s.folder, device) - ldbWithNeed(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn)) + s.db.withNeed([]byte(s.folder), device[:], true, nativeFileIterator(fn)) } func (s *FileSet) WithHave(device protocol.DeviceID, fn Iterator) { l.Debugf("%s WithHave(%v)", s.folder, device) - ldbWithHave(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn)) + s.db.withHave([]byte(s.folder), device[:], false, nativeFileIterator(fn)) } func (s *FileSet) WithHaveTruncated(device protocol.DeviceID, fn Iterator) { l.Debugf("%s WithHaveTruncated(%v)", s.folder, device) - ldbWithHave(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn)) + s.db.withHave([]byte(s.folder), device[:], true, nativeFileIterator(fn)) } func (s *FileSet) WithGlobal(fn Iterator) { l.Debugf("%s WithGlobal()", s.folder) - ldbWithGlobal(s.db, []byte(s.folder), nil, false, nativeFileIterator(fn)) + s.db.withGlobal([]byte(s.folder), nil, false, nativeFileIterator(fn)) } func (s *FileSet) WithGlobalTruncated(fn Iterator) { l.Debugf("%s WithGlobalTruncated()", s.folder) - ldbWithGlobal(s.db, []byte(s.folder), nil, true, nativeFileIterator(fn)) + s.db.withGlobal([]byte(s.folder), nil, true, nativeFileIterator(fn)) } func (s *FileSet) WithPrefixedGlobalTruncated(prefix string, fn Iterator) { l.Debugf("%s WithPrefixedGlobalTruncated()", s.folder, prefix) - ldbWithGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(prefix)), true, nativeFileIterator(fn)) + s.db.withGlobal([]byte(s.folder), []byte(osutil.NormalizedFilename(prefix)), true, nativeFileIterator(fn)) } func (s *FileSet) Get(device protocol.DeviceID, file string) (protocol.FileInfo, bool) { @@ -202,7 +202,7 @@ func (s *FileSet) Get(device protocol.DeviceID, file string) (protocol.FileInfo, } func (s *FileSet) GetGlobal(file string) (protocol.FileInfo, bool) { - fi, ok := ldbGetGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)), false) + fi, ok := s.db.getGlobal([]byte(s.folder), []byte(osutil.NormalizedFilename(file)), false) if !ok { return protocol.FileInfo{}, false } @@ -212,7 +212,7 @@ func (s *FileSet) GetGlobal(file string) (protocol.FileInfo, bool) { } func (s *FileSet) GetGlobalTruncated(file string) (FileInfoTruncated, bool) { - fi, ok := ldbGetGlobal(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file)), true) + fi, ok := s.db.getGlobal([]byte(s.folder), []byte(osutil.NormalizedFilename(file)), true) if !ok { return FileInfoTruncated{}, false } @@ -222,7 +222,7 @@ func (s *FileSet) GetGlobalTruncated(file string) (FileInfoTruncated, bool) { } func (s *FileSet) Availability(file string) []protocol.DeviceID { - return ldbAvailability(s.db, []byte(s.folder), []byte(osutil.NormalizedFilename(file))) + return s.db.availability([]byte(s.folder), []byte(osutil.NormalizedFilename(file))) } func (s *FileSet) LocalVersion(device protocol.DeviceID) int64 { @@ -241,13 +241,15 @@ func (s *FileSet) GlobalSize() (files, deleted int, bytes int64) { // ListFolders returns the folder IDs seen in the database. func ListFolders(db *leveldb.DB) []string { - return ldbListFolders(db) + i := &dbInstance{db} + return i.listFolders() } // DropFolder clears out all information related to the given folder from the // database. func DropFolder(db *leveldb.DB, folder string) { - ldbDropFolder(db, []byte(folder)) + i := &dbInstance{db} + i.dropFolder([]byte(folder)) bm := &BlockMap{ db: db, folder: folder,