syncthing/lib/db/blockmap.go

239 lines
6.0 KiB
Go
Raw 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 http://mozilla.org/MPL/2.0/.
2014-10-06 20:57:33 +00:00
// Package db provides a set type to track local/remote files with newness
2014-10-06 20:57:33 +00:00
// checks. We must do a certain amount of normalization in here. We will get
// fed paths with either native or wire-format separators and encodings
// depending on who calls us. We transform paths to wire-format (NFC and
// slashes) on the way to the database, and transform to native format
// (varying separator and encoding) on the way back out.
package db
2014-10-06 20:57:33 +00:00
import (
"bytes"
"encoding/binary"
"fmt"
2014-10-06 20:57:33 +00:00
2015-08-06 09:29:25 +00:00
"github.com/syncthing/syncthing/lib/osutil"
2015-09-22 17:38:46 +00:00
"github.com/syncthing/syncthing/lib/protocol"
2014-10-06 20:57:33 +00:00
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/util"
)
var blockFinder *BlockFinder
2015-10-21 21:03:42 +00:00
const maxBatchSize = 256 << 10
2014-10-06 20:57:33 +00:00
type BlockMap struct {
db *leveldb.DB
folder string
}
func NewBlockMap(db *leveldb.DB, folder string) *BlockMap {
return &BlockMap{
db: db,
folder: folder,
}
}
// Add files to the block map, ignoring any deleted or invalid files.
func (m *BlockMap) Add(files []protocol.FileInfo) error {
batch := new(leveldb.Batch)
buf := make([]byte, 4)
var key []byte
2014-10-06 20:57:33 +00:00
for _, file := range files {
2015-10-21 21:03:42 +00:00
if batch.Len() > maxBatchSize {
if err := m.db.Write(batch, nil); err != nil {
return err
}
batch.Reset()
}
2014-10-06 20:57:33 +00:00
if file.IsDirectory() || file.IsDeleted() || file.IsInvalid() {
continue
}
for i, block := range file.Blocks {
binary.BigEndian.PutUint32(buf, uint32(i))
key = m.blockKeyInto(key, block.Hash, file.Name)
batch.Put(key, buf)
2014-10-06 20:57:33 +00:00
}
}
return m.db.Write(batch, nil)
}
// Update block map state, removing any deleted or invalid files.
func (m *BlockMap) Update(files []protocol.FileInfo) error {
batch := new(leveldb.Batch)
buf := make([]byte, 4)
var key []byte
2014-10-06 20:57:33 +00:00
for _, file := range files {
2015-10-21 21:03:42 +00:00
if batch.Len() > maxBatchSize {
if err := m.db.Write(batch, nil); err != nil {
return err
}
batch.Reset()
}
2014-10-06 20:57:33 +00:00
if file.IsDirectory() {
continue
}
if file.IsDeleted() || file.IsInvalid() {
for _, block := range file.Blocks {
key = m.blockKeyInto(key, block.Hash, file.Name)
batch.Delete(key)
2014-10-06 20:57:33 +00:00
}
continue
}
for i, block := range file.Blocks {
binary.BigEndian.PutUint32(buf, uint32(i))
key = m.blockKeyInto(key, block.Hash, file.Name)
batch.Put(key, buf)
2014-10-06 20:57:33 +00:00
}
}
return m.db.Write(batch, nil)
}
// Discard block map state, removing the given files
func (m *BlockMap) Discard(files []protocol.FileInfo) error {
batch := new(leveldb.Batch)
var key []byte
for _, file := range files {
2015-10-21 21:03:42 +00:00
if batch.Len() > maxBatchSize {
if err := m.db.Write(batch, nil); err != nil {
return err
}
batch.Reset()
}
for _, block := range file.Blocks {
key = m.blockKeyInto(key, block.Hash, file.Name)
batch.Delete(key)
}
}
return m.db.Write(batch, nil)
}
2014-10-06 20:57:33 +00:00
// Drop block map, removing all entries related to this block map from the db.
func (m *BlockMap) Drop() error {
batch := new(leveldb.Batch)
iter := m.db.NewIterator(util.BytesPrefix(m.blockKeyInto(nil, nil, "")[:1+64]), nil)
2014-10-06 20:57:33 +00:00
defer iter.Release()
for iter.Next() {
2015-10-21 21:03:42 +00:00
if batch.Len() > maxBatchSize {
if err := m.db.Write(batch, nil); err != nil {
return err
}
batch.Reset()
}
2014-10-06 20:57:33 +00:00
batch.Delete(iter.Key())
}
if iter.Error() != nil {
return iter.Error()
}
return m.db.Write(batch, nil)
}
func (m *BlockMap) blockKeyInto(o, hash []byte, file string) []byte {
return blockKeyInto(o, hash, m.folder, file)
2014-10-06 20:57:33 +00:00
}
type BlockFinder struct {
2015-09-04 10:01:00 +00:00
db *leveldb.DB
2014-10-06 20:57:33 +00:00
}
2015-09-04 10:01:00 +00:00
func NewBlockFinder(db *leveldb.DB) *BlockFinder {
2014-10-06 20:57:33 +00:00
if blockFinder != nil {
return blockFinder
}
f := &BlockFinder{
2015-09-04 10:01:00 +00:00
db: db,
2014-10-06 20:57:33 +00:00
}
2014-10-06 20:57:33 +00:00
return f
}
func (f *BlockFinder) String() string {
return fmt.Sprintf("BlockFinder@%p", f)
2014-10-06 20:57:33 +00:00
}
2015-04-28 20:32:10 +00:00
// Iterate takes an iterator function which iterates over all matching blocks
// for the given hash. The iterator function has to return either true (if
// they are happy with the block) or false to continue iterating for whatever
// reason. The iterator finally returns the result, whether or not a
// satisfying block was eventually found.
2015-09-04 10:01:00 +00:00
func (f *BlockFinder) Iterate(folders []string, hash []byte, iterFn func(string, string, int32) bool) bool {
var key []byte
2014-10-06 20:57:33 +00:00
for _, folder := range folders {
key = blockKeyInto(key, hash, folder, "")
2014-10-06 20:57:33 +00:00
iter := f.db.NewIterator(util.BytesPrefix(key), nil)
defer iter.Release()
for iter.Next() && iter.Error() == nil {
folder, file := fromBlockKey(iter.Key())
index := int32(binary.BigEndian.Uint32(iter.Value()))
2014-11-05 23:41:51 +00:00
if iterFn(folder, osutil.NativeFilename(file), index) {
2014-10-06 20:57:33 +00:00
return true
}
}
}
return false
}
2015-04-28 20:32:10 +00:00
// Fix repairs incorrect blockmap entries, removing the old entry and
// replacing it with a new entry for the given block
func (f *BlockFinder) Fix(folder, file string, index int32, oldHash, newHash []byte) error {
2014-10-24 22:20:08 +00:00
buf := make([]byte, 4)
binary.BigEndian.PutUint32(buf, uint32(index))
batch := new(leveldb.Batch)
batch.Delete(blockKeyInto(nil, oldHash, folder, file))
batch.Put(blockKeyInto(nil, newHash, folder, file), buf)
2014-10-24 22:20:08 +00:00
return f.db.Write(batch, nil)
}
2014-10-06 20:57:33 +00:00
// m.blockKey returns a byte slice encoding the following information:
// keyTypeBlock (1 byte)
// folder (64 bytes)
2014-10-17 23:39:36 +00:00
// block hash (32 bytes)
2014-10-06 20:57:33 +00:00
// file name (variable size)
func blockKeyInto(o, hash []byte, folder, file string) []byte {
reqLen := 1 + 64 + 32 + len(file)
if cap(o) < reqLen {
o = make([]byte, reqLen)
} else {
o = o[:reqLen]
}
2015-01-17 19:53:33 +00:00
o[0] = KeyTypeBlock
2014-10-06 20:57:33 +00:00
copy(o[1:], []byte(folder))
copy(o[1+64:], []byte(hash))
2014-10-17 23:39:36 +00:00
copy(o[1+64+32:], []byte(file))
2014-10-06 20:57:33 +00:00
return o
}
func fromBlockKey(data []byte) (string, string) {
2014-10-17 23:39:36 +00:00
if len(data) < 1+64+32+1 {
2014-10-06 20:57:33 +00:00
panic("Incorrect key length")
}
2015-01-17 19:53:33 +00:00
if data[0] != KeyTypeBlock {
2014-10-06 20:57:33 +00:00
panic("Incorrect key type")
}
2014-10-17 23:39:36 +00:00
file := string(data[1+64+32:])
2014-10-06 20:57:33 +00:00
slice := data[1 : 1+64]
izero := bytes.IndexByte(slice, 0)
if izero > -1 {
return string(slice[:izero]), file
}
return string(slice), file
}