syncthing/lib/db/blockmap_test.go

259 lines
5.4 KiB
Go
Raw Permalink Normal View History

2014-11-16 20:13:20 +00:00
// Copyright (C) 2014 The Syncthing Authors.
2014-10-06 20:57:33 +00:00
//
2015-03-07 20:36:35 +00:00
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at https://mozilla.org/MPL/2.0/.
2014-10-06 20:57:33 +00:00
package db
2014-10-06 20:57:33 +00:00
import (
"encoding/binary"
2014-10-06 20:57:33 +00:00
"testing"
2015-09-22 17:38:46 +00:00
"github.com/syncthing/syncthing/lib/protocol"
2014-10-06 20:57:33 +00:00
)
var f1, f2, f3 protocol.FileInfo
2015-09-04 10:01:00 +00:00
var folders = []string{"folder1", "folder2"}
2014-10-06 20:57:33 +00:00
func init() {
blocks := genBlocks(30)
f1 = protocol.FileInfo{
Name: "f1",
Blocks: blocks[:10],
}
f2 = protocol.FileInfo{
Name: "f2",
Blocks: blocks[10:20],
}
f3 = protocol.FileInfo{
Name: "f3",
Blocks: blocks[20:],
}
}
func setup(t testing.TB) (*Lowlevel, *BlockFinder) {
t.Helper()
db := newLowlevelMemory(t)
return db, NewBlockFinder(db)
2014-10-06 20:57:33 +00:00
}
func dbEmpty(db *Lowlevel) bool {
iter, err := db.NewPrefixIterator([]byte{KeyTypeBlock})
if err != nil {
panic(err)
}
2014-10-06 20:57:33 +00:00
defer iter.Release()
return !iter.Next()
2014-10-06 20:57:33 +00:00
}
func addToBlockMap(db *Lowlevel, folder []byte, fs []protocol.FileInfo) error {
t, err := db.newReadWriteTransaction()
if err != nil {
return err
}
defer t.close()
var keyBuf []byte
blockBuf := make([]byte, 4)
for _, f := range fs {
if !f.IsDirectory() && !f.IsDeleted() && !f.IsInvalid() {
name := []byte(f.Name)
for i, block := range f.Blocks {
binary.BigEndian.PutUint32(blockBuf, uint32(i))
keyBuf, err = t.keyer.GenerateBlockMapKey(keyBuf, folder, block.Hash, name)
if err != nil {
return err
}
if err := t.Put(keyBuf, blockBuf); err != nil {
return err
}
}
}
}
return t.Commit()
}
func discardFromBlockMap(db *Lowlevel, folder []byte, fs []protocol.FileInfo) error {
t, err := db.newReadWriteTransaction()
if err != nil {
return err
}
defer t.close()
var keyBuf []byte
for _, ef := range fs {
if !ef.IsDirectory() && !ef.IsDeleted() && !ef.IsInvalid() {
name := []byte(ef.Name)
for _, block := range ef.Blocks {
keyBuf, err = t.keyer.GenerateBlockMapKey(keyBuf, folder, block.Hash, name)
if err != nil {
return err
}
if err := t.Delete(keyBuf); err != nil {
return err
}
}
}
}
return t.Commit()
}
2014-10-06 20:57:33 +00:00
func TestBlockMapAddUpdateWipe(t *testing.T) {
db, f := setup(t)
defer db.Close()
2014-10-06 20:57:33 +00:00
if !dbEmpty(db) {
t.Fatal("db not empty")
}
folder := []byte("folder1")
2014-10-06 20:57:33 +00:00
f3.Type = protocol.FileInfoTypeDirectory
2014-10-06 20:57:33 +00:00
if err := addToBlockMap(db, folder, []protocol.FileInfo{f1, f2, f3}); err != nil {
t.Fatal(err)
}
2014-10-06 20:57:33 +00:00
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f1.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
if folder != "folder1" || file != "f1" || index != 0 {
t.Fatal("Mismatch")
}
return true
})
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f2.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
if folder != "folder1" || file != "f2" || index != 0 {
t.Fatal("Mismatch")
}
return true
})
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f3.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
t.Fatal("Unexpected block")
return true
})
if err := discardFromBlockMap(db, folder, []protocol.FileInfo{f1, f2, f3}); err != nil {
t.Fatal(err)
}
f1.Deleted = true
f2.LocalFlags = protocol.FlagLocalMustRescan // one of the invalid markers
2014-10-06 20:57:33 +00:00
if err := addToBlockMap(db, folder, []protocol.FileInfo{f1, f2, f3}); err != nil {
t.Fatal(err)
}
2014-10-06 20:57:33 +00:00
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f1.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
t.Fatal("Unexpected block")
return false
})
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f2.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
t.Fatal("Unexpected block")
return false
})
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f3.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
if folder != "folder1" || file != "f3" || index != 0 {
t.Fatal("Mismatch")
}
return true
})
if err := db.dropFolder(folder); err != nil {
t.Fatal(err)
}
2014-10-06 20:57:33 +00:00
if !dbEmpty(db) {
t.Fatal("db not empty")
}
// Should not add
if err := addToBlockMap(db, folder, []protocol.FileInfo{f1, f2}); err != nil {
t.Fatal(err)
}
2014-10-06 20:57:33 +00:00
if !dbEmpty(db) {
t.Fatal("db not empty")
}
f1.Deleted = false
f1.LocalFlags = 0
f2.Deleted = false
f2.LocalFlags = 0
f3.Deleted = false
f3.LocalFlags = 0
2014-10-06 20:57:33 +00:00
}
2014-10-24 21:23:19 +00:00
func TestBlockFinderLookup(t *testing.T) {
db, f := setup(t)
defer db.Close()
2014-10-06 20:57:33 +00:00
folder1 := []byte("folder1")
folder2 := []byte("folder2")
2014-10-06 20:57:33 +00:00
if err := addToBlockMap(db, folder1, []protocol.FileInfo{f1}); err != nil {
t.Fatal(err)
}
if err := addToBlockMap(db, folder2, []protocol.FileInfo{f1}); err != nil {
t.Fatal(err)
}
2014-10-06 20:57:33 +00:00
counter := 0
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f1.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
counter++
switch counter {
case 1:
if folder != "folder1" || file != "f1" || index != 0 {
t.Fatal("Mismatch")
}
case 2:
if folder != "folder2" || file != "f1" || index != 0 {
t.Fatal("Mismatch")
}
default:
t.Fatal("Unexpected block")
}
return false
})
2015-09-04 10:01:00 +00:00
2014-10-06 20:57:33 +00:00
if counter != 2 {
t.Fatal("Incorrect count", counter)
}
if err := discardFromBlockMap(db, folder1, []protocol.FileInfo{f1}); err != nil {
t.Fatal(err)
}
f1.Deleted = true
2014-10-06 20:57:33 +00:00
if err := addToBlockMap(db, folder1, []protocol.FileInfo{f1}); err != nil {
t.Fatal(err)
}
2014-10-06 20:57:33 +00:00
counter = 0
2015-09-04 10:01:00 +00:00
f.Iterate(folders, f1.Blocks[0].Hash, func(folder, file string, index int32) bool {
2014-10-06 20:57:33 +00:00
counter++
switch counter {
case 1:
if folder != "folder2" || file != "f1" || index != 0 {
t.Fatal("Mismatch")
}
default:
t.Fatal("Unexpected block")
}
return false
})
2015-09-04 10:01:00 +00:00
2014-10-06 20:57:33 +00:00
if counter != 1 {
t.Fatal("Incorrect count")
}
2014-10-24 21:23:19 +00:00
f1.Deleted = false
2014-10-06 20:57:33 +00:00
}