feat: make block indexing configurable (#10608)

This adds a new folder-level configuration `FullBlockIndex`. It controls whether we maintain the block index for a given folder -- currently that's always true, now it becomes possible to turn off. The block index is used for lookup of blocks across files and folders. Effectively, when syncing a change, for each block, we check: 1. Is the block already present in the old version of the file? If so, we can reuse (copy) it without network transfer. **This check is always possible.** 2. Is the block already present in any other file in this folder or other folders? If so we can copy it. **This check is only possible with the full block index.** 3. We must transfer the block over the network. Maintaining the full block index is costly in time, I/O and database size. With this PR, maintaining the full block index becomes the default for send-receive and receive-only folders only, with it disabled for send-only and receive-encrypted folders. The block index is never useful for encrypted folders, as blocks are encrypted separate for each file. It is also not useful for send-only folders by themselves, though the data in the send-only folder could be reused by other receive-type folders if it were enabled. For very large folders it may make sense to disable the full block index regardless of folder type and just accept the resulting decrease in data reuse. Disabling or enabling the option in the GUI causes the index to be destroyed or rebuilt accordingly. https://github.com/syncthing/docs/pull/1005 --------- Signed-off-by: Jakob Borg <jakob@kastelo.net>
2026-04-26 11:58:09 +02:00
parent 84c6b37913
commit 86ac4e5017
19 changed files with 449 additions and 36 deletions
@@ -92,12 +92,35 @@ func (s *DB) getFolderDB(folder string, create bool) (*folderDB, error) {
 	return fdb, nil
 }

-func (s *DB) Update(folder string, device protocol.DeviceID, fs []protocol.FileInfo) error {
+func (s *DB) Update(folder string, device protocol.DeviceID, fs []protocol.FileInfo, opts ...db.UpdateOption) error {
 	fdb, err := s.getFolderDB(folder, true)
 	if err != nil {
 		return err
 	}
-	return fdb.Update(device, fs)
+	var options db.UpdateOptions
+	for _, o := range opts {
+		o(&options)
+	}
+	return fdb.Update(device, fs, options)
+}
+
+func (s *DB) DropBlockIndex(folder string) error {
+	fdb, err := s.getFolderDB(folder, false)
+	if errors.Is(err, errNoSuchFolder) {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	return fdb.DropBlockIndex()
+}
+
+func (s *DB) PopulateBlockIndex(folder string) error {
+	fdb, err := s.getFolderDB(folder, true)
+	if err != nil {
+		return err
+	}
+	return fdb.PopulateBlockIndex()
 }

 func (s *DB) GetDeviceFile(folder string, device protocol.DeviceID, file string) (protocol.FileInfo, bool, error) {
@@ -9,6 +9,7 @@ package sqlite
 import (
 	"testing"

+	"github.com/syncthing/syncthing/internal/db"
 	"github.com/syncthing/syncthing/internal/itererr"
 	"github.com/syncthing/syncthing/lib/protocol"
 )
@@ -138,6 +139,211 @@ func TestBlocksDeleted(t *testing.T) {
 	}
 }

+func TestDropBlockIndex(t *testing.T) {
+	t.Parallel()
+
+	sdb, err := Open(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { sdb.Close() })
+
+	// Insert files with blocks
+	files := []protocol.FileInfo{
+		genFile("a", 3, 0),
+		genFile("b", 2, 0),
+	}
+	if err := sdb.Update(folderID, protocol.LocalDeviceID, files); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify blocks exist
+	hits, err := itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, files[0].Blocks[0].Hash))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(hits) == 0 {
+		t.Fatal("expected block hits before drop")
+	}
+
+	// Drop the block index
+	if err := sdb.DropBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify blocks are gone
+	hits, err = itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, files[0].Blocks[0].Hash))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(hits) != 0 {
+		t.Fatal("expected no block hits after drop")
+	}
+
+	// Dropping again should be a no-op (already empty)
+	if err := sdb.DropBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+
+	// Dropping a nonexistent folder should be fine
+	if err := sdb.DropBlockIndex("nonexistent"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestPopulateBlockIndex(t *testing.T) {
+	t.Parallel()
+
+	sdb, err := Open(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { sdb.Close() })
+
+	// Insert files with blocks
+	files := []protocol.FileInfo{
+		genFile("a", 3, 0),
+		genFile("b", 2, 0),
+	}
+	if err := sdb.Update(folderID, protocol.LocalDeviceID, files); err != nil {
+		t.Fatal(err)
+	}
+
+	// Collect the original block entries for comparison
+	origHitsA, err := itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, files[0].Blocks[0].Hash))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(origHitsA) != 1 {
+		t.Fatal("expected one hit for block a[0]")
+	}
+
+	// Drop the block index
+	if err := sdb.DropBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+
+	// Populate it back from existing blocklists
+	if err := sdb.PopulateBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify all blocks are back
+	for i, f := range files {
+		for j, b := range f.Blocks {
+			hits, err := itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, b.Hash))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(hits) == 0 {
+				t.Errorf("file %d block %d: expected hits after populate", i, j)
+			}
+		}
+	}
+
+	// Populating again should be a no-op (not empty)
+	if err := sdb.PopulateBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestPopulateBlockIndexSkipsRemoteFiles(t *testing.T) {
+	t.Parallel()
+
+	sdb, err := Open(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { sdb.Close() })
+
+	// Insert a local file (blocks indexed) and a remote file (blocks not indexed)
+	localFile := genFile("local", 2, 0)
+	if err := sdb.Update(folderID, protocol.LocalDeviceID, []protocol.FileInfo{localFile}); err != nil {
+		t.Fatal(err)
+	}
+	remoteFile := genFile("remote", 2, 1)
+	if err := sdb.Update(folderID, protocol.DeviceID{42}, []protocol.FileInfo{remoteFile}); err != nil {
+		t.Fatal(err)
+	}
+
+	// Drop and repopulate
+	if err := sdb.DropBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+	if err := sdb.PopulateBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+
+	// Local file blocks should be present
+	hits, err := itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, localFile.Blocks[0].Hash))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(hits) == 0 {
+		t.Error("expected hits for local file blocks")
+	}
+
+	// Remote file blocks should not be present (blocks are only
+	// indexed for local files)
+	hits, err = itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, remoteFile.Blocks[0].Hash))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(hits) != 0 {
+		t.Error("expected no hits for remote file blocks")
+	}
+}
+
+func TestSkipBlockIndexOnUpdate(t *testing.T) {
+	t.Parallel()
+
+	sdb, err := Open(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { sdb.Close() })
+
+	// Insert a file with SkipBlockIndex
+	file := genFile("a", 3, 0)
+	if err := sdb.Update(folderID, protocol.LocalDeviceID, []protocol.FileInfo{file}, db.WithSkipBlockIndex()); err != nil {
+		t.Fatal(err)
+	}
+
+	// Blocks should not be indexed
+	hits, err := itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, file.Blocks[0].Hash))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(hits) != 0 {
+		t.Fatal("expected no block hits with SkipBlockIndex")
+	}
+
+	// The blocklist should still be stored (file info is retrievable with blocks)
+	fi, ok, err := sdb.GetDeviceFile(folderID, protocol.LocalDeviceID, "a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !ok {
+		t.Fatal("file not found")
+	}
+	if len(fi.Blocks) != 3 {
+		t.Fatalf("expected 3 blocks in file info, got %d", len(fi.Blocks))
+	}
+
+	// Populate should fill in the blocks
+	if err := sdb.PopulateBlockIndex(folderID); err != nil {
+		t.Fatal(err)
+	}
+
+	hits, err = itererr.Collect(sdb.AllLocalBlocksWithHash(folderID, file.Blocks[0].Hash))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(hits) != 1 {
+		t.Fatal("expected one hit after populate")
+	}
+}
+
 func TestRemoteSequence(t *testing.T) {
 	t.Parallel()

@@ -14,6 +14,7 @@ import (
 	"slices"

 	"github.com/jmoiron/sqlx"
+	"github.com/syncthing/syncthing/internal/db"
 	"github.com/syncthing/syncthing/internal/gen/dbproto"
 	"github.com/syncthing/syncthing/internal/itererr"
 	"github.com/syncthing/syncthing/internal/slogutil"
@@ -30,7 +31,7 @@ const (
 	updatePointsThreshold = 250_000
 )

-func (s *folderDB) Update(device protocol.DeviceID, fs []protocol.FileInfo) error {
+func (s *folderDB) Update(device protocol.DeviceID, fs []protocol.FileInfo, options db.UpdateOptions) error {
 	s.updateLock.Lock()
 	defer s.updateLock.Unlock()

@@ -151,7 +152,7 @@ func (s *folderDB) Update(device protocol.DeviceID, fs []protocol.FileInfo) erro
 			}
 			if _, err := insertBlockListStmt.Exec(f.BlocksHash, bs); err != nil {
 				return wrap(err, "insert blocklist")
-			} else if device == protocol.LocalDeviceID {
+			} else if device == protocol.LocalDeviceID && !options.SkipBlockIndex {
 				// Insert all blocks
 				if err := s.insertBlocksLocked(txp, f.BlocksHash, f.Blocks); err != nil {
 					return wrap(err, "insert blocks")
@@ -303,6 +304,86 @@ func (s *folderDB) DropFilesNamed(device protocol.DeviceID, names []string) erro
 	return wrap(tx.Commit())
 }

+func (s *folderDB) blockIndexEmpty() (bool, error) {
+	var exists bool
+	err := s.sql.Get(&exists, `SELECT EXISTS (SELECT 1 FROM blocks LIMIT 1)`)
+	if err != nil {
+		return false, wrap(err)
+	}
+	return !exists, nil
+}
+
+func (s *folderDB) DropBlockIndex() error {
+	s.updateLock.Lock()
+	defer s.updateLock.Unlock()
+
+	empty, err := s.blockIndexEmpty()
+	if err != nil || empty {
+		return err
+	}
+
+	if _, err := s.sql.Exec(`DELETE FROM blocks`); err != nil {
+		return wrap(err)
+	}
+
+	return s.vacuumAndOptimize()
+}
+
+func (s *folderDB) PopulateBlockIndex() error {
+	s.updateLock.Lock()
+	defer s.updateLock.Unlock()
+
+	empty, err := s.blockIndexEmpty()
+	if err != nil || !empty {
+		return err
+	}
+
+	tx, err := s.sql.BeginTxx(context.Background(), nil)
+	if err != nil {
+		return wrap(err)
+	}
+	defer tx.Rollback()
+	txp := &txPreparedStmts{Tx: tx}
+
+	// Iterate all local files that have a blocklist
+	rows, err := tx.Queryx(`
+		SELECT f.blocklist_hash, bl.blprotobuf FROM files f
+		INNER JOIN blocklists bl ON bl.blocklist_hash = f.blocklist_hash
+		WHERE f.device_idx = ? AND f.blocklist_hash IS NOT NULL
+	`, s.localDeviceIdx)
+	if err != nil {
+		return wrap(err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var blocklistHash []byte
+		var blProtobuf []byte
+		if err := rows.Scan(&blocklistHash, &blProtobuf); err != nil {
+			return wrap(err)
+		}
+
+		var bl dbproto.BlockList
+		if err := proto.Unmarshal(blProtobuf, &bl); err != nil {
+			return wrap(err, "unmarshal blocklist")
+		}
+
+		blocks := make([]protocol.BlockInfo, len(bl.Blocks))
+		for i, b := range bl.Blocks {
+			blocks[i] = protocol.BlockInfoFromWire(b)
+		}
+
+		if err := s.insertBlocksLocked(txp, blocklistHash, blocks); err != nil {
+			return wrap(err, "insert blocks")
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return wrap(err)
+	}
+
+	return wrap(tx.Commit())
+}
+
 func (*folderDB) insertBlocksLocked(tx *txPreparedStmts, blocklistHash []byte, blocks []protocol.BlockInfo) error {
 	if len(blocks) == 0 {
 		return nil