Implement database abstraction, error checking (ref #5907) (#6107)

This PR does two things, because one lead to the other:

- Move the leveldb specific stuff into a small "backend" package that
defines a backend interface and the leveldb implementation. This allows,
potentially, in the future, switching the db implementation so another
KV store should we wish to do so.

- Add proper error handling all along the way. The db and backend
packages are now errcheck clean. However, I drew the line at modifying
the FileSet API in order to keep this manageable and not continue
refactoring all of the rest of Syncthing. As such, the FileSet methods
still panic on database errors, except for the "database is closed"
error which is instead handled by silently returning as quickly as
possible, with the assumption that we're anyway "on the way out".

lib/db/db_test.go

@@ -9,17 +9,33 @@ package db
 import (
 	"testing"
 
+	"github.com/syncthing/syncthing/lib/db/backend"
 	"github.com/syncthing/syncthing/lib/fs"
 	"github.com/syncthing/syncthing/lib/protocol"
 )
 
+func genBlocks(n int) []protocol.BlockInfo {
+	b := make([]protocol.BlockInfo, n)
+	for i := range b {
+		h := make([]byte, 32)
+		for j := range h {
+			h[j] = byte(i + j)
+		}
+		b[i].Size = int32(i)
+		b[i].Hash = h
+	}
+	return b
+}
+
 func TestIgnoredFiles(t *testing.T) {
 	ldb, err := openJSONS("testdata/v0.14.48-ignoredfiles.db.jsons")
 	if err != nil {
 		t.Fatal(err)
 	}
-	db := NewLowlevel(ldb, "<memory>")
-	UpdateSchema(db)
+	db := NewLowlevel(ldb)
+	if err := UpdateSchema(db); err != nil {
+		t.Fatal(err)
+	}
 
 	fs := NewFileSet("test", fs.NewFilesystem(fs.FilesystemTypeBasic, "."), db)
 
@@ -142,25 +158,35 @@ func TestUpdate0to3(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	db := newInstance(NewLowlevel(ldb, "<memory>"))
+	db := newInstance(NewLowlevel(ldb))
 	updater := schemaUpdater{db}
 
 	folder := []byte(update0to3Folder)
 
-	updater.updateSchema0to1()
+	if err := updater.updateSchema0to1(); err != nil {
+		t.Fatal(err)
+	}
 
-	if _, ok := db.getFileDirty(folder, protocol.LocalDeviceID[:], []byte(slashPrefixed)); ok {
+	if _, ok, err := db.getFileDirty(folder, protocol.LocalDeviceID[:], []byte(slashPrefixed)); err != nil {
+		t.Fatal(err)
+	} else if ok {
 		t.Error("File prefixed by '/' was not removed during transition to schema 1")
 	}
 
-	if _, err := db.Get(db.keyer.GenerateGlobalVersionKey(nil, folder, []byte(invalid)), nil); err != nil {
+	key, err := db.keyer.GenerateGlobalVersionKey(nil, folder, []byte(invalid))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := db.Get(key); err != nil {
 		t.Error("Invalid file wasn't added to global list")
 	}
 
-	updater.updateSchema1to2()
+	if err := updater.updateSchema1to2(); err != nil {
+		t.Fatal(err)
+	}
 
 	found := false
-	db.withHaveSequence(folder, 0, func(fi FileIntf) bool {
+	_ = db.withHaveSequence(folder, 0, func(fi FileIntf) bool {
 		f := fi.(protocol.FileInfo)
 		l.Infoln(f)
 		if found {
@@ -178,14 +204,16 @@ func TestUpdate0to3(t *testing.T) {
 		t.Error("Local file wasn't added to sequence bucket", err)
 	}
 
-	updater.updateSchema2to3()
+	if err := updater.updateSchema2to3(); err != nil {
+		t.Fatal(err)
+	}
 
 	need := map[string]protocol.FileInfo{
 		haveUpdate0to3[remoteDevice0][0].Name: haveUpdate0to3[remoteDevice0][0],
 		haveUpdate0to3[remoteDevice1][0].Name: haveUpdate0to3[remoteDevice1][0],
 		haveUpdate0to3[remoteDevice0][2].Name: haveUpdate0to3[remoteDevice0][2],
 	}
-	db.withNeed(folder, protocol.LocalDeviceID[:], false, func(fi FileIntf) bool {
+	_ = db.withNeed(folder, protocol.LocalDeviceID[:], false, func(fi FileIntf) bool {
 		e, ok := need[fi.FileName()]
 		if !ok {
 			t.Error("Got unexpected needed file:", fi.FileName())
@@ -203,12 +231,17 @@ func TestUpdate0to3(t *testing.T) {
 }
 
 func TestDowngrade(t *testing.T) {
-	db := OpenMemory()
-	UpdateSchema(db) // sets the min version etc
+	db := NewLowlevel(backend.OpenMemory())
+	// sets the min version etc
+	if err := UpdateSchema(db); err != nil {
+		t.Fatal(err)
+	}
 
 	// Bump the database version to something newer than we actually support
 	miscDB := NewMiscDataNamespace(db)
-	miscDB.PutInt64("dbVersion", dbVersion+1)
+	if err := miscDB.PutInt64("dbVersion", dbVersion+1); err != nil {
+		t.Fatal(err)
+	}
 	l.Infoln(dbVersion)
 
 	// Pretend we just opened the DB and attempt to update it again