b1b68ceedb
We have the invalid bit to indicate that a file isn't good. That's enough for remote devices. For ourselves, it would be good to know sometimes why the file isn't good - because it's an unsupported type, because it matches an ignore pattern, or because we detected the data is bad and we need to rescan it.
Or, and this is the main future reason for the PR, because it's a change detected on a receive only device. We will want something like the invalid flag for those changes, but marking them as invalid today means the scanner will rehash them. Hence something more fine grained is required.
This introduces a LocalFlags fields to the FileInfo where we can stash things that we care about locally. For example,
FlagLocalUnsupported = 1 << 0 // The kind is unsupported, e.g. symlinks on Windows
FlagLocalIgnored = 1 << 1 // Matches local ignore patterns
FlagLocalMustRescan = 1 << 2 // Doesn't match content on disk, must be rechecked fully
The LocalFlags fields isn't sent over the wire; instead the Invalid attribute is calculated based on the flags at index sending time. It's on the FileInfo anyway because that's what we serialize to database etc.
The actual Invalid flag should after this just be considered when building the global state and figuring out availability for remote devices. It is not used for local file index entries.
135 lines
3.4 KiB
Go
135 lines
3.4 KiB
Go
// Copyright (C) 2014 The Syncthing Authors.
|
|
//
|
|
// 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/.
|
|
|
|
package db
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
|
|
"github.com/syncthing/syncthing/lib/protocol"
|
|
)
|
|
|
|
const (
|
|
KeyTypeDevice = iota
|
|
KeyTypeGlobal
|
|
KeyTypeBlock
|
|
KeyTypeDeviceStatistic
|
|
KeyTypeFolderStatistic
|
|
KeyTypeVirtualMtime
|
|
KeyTypeFolderIdx
|
|
KeyTypeDeviceIdx
|
|
KeyTypeIndexID
|
|
KeyTypeFolderMeta
|
|
KeyTypeMiscData
|
|
KeyTypeSequence
|
|
KeyTypeNeed
|
|
)
|
|
|
|
func (vl VersionList) String() string {
|
|
var b bytes.Buffer
|
|
var id protocol.DeviceID
|
|
b.WriteString("{")
|
|
for i, v := range vl.Versions {
|
|
if i > 0 {
|
|
b.WriteString(", ")
|
|
}
|
|
copy(id[:], v.Device)
|
|
fmt.Fprintf(&b, "{%v, %v}", v.Version, id)
|
|
}
|
|
b.WriteString("}")
|
|
return b.String()
|
|
}
|
|
|
|
// update brings the VersionList up to date with file. It returns the updated
|
|
// VersionList, a potentially removed old FileVersion and its index, as well as
|
|
// the index where the new FileVersion was inserted.
|
|
func (vl VersionList) update(folder, device []byte, file protocol.FileInfo, db *Instance) (_ VersionList, removedFV FileVersion, removedAt int, insertedAt int) {
|
|
removedAt, insertedAt = -1, -1
|
|
for i, v := range vl.Versions {
|
|
if bytes.Equal(v.Device, device) {
|
|
removedAt = i
|
|
removedFV = v
|
|
vl.Versions = append(vl.Versions[:i], vl.Versions[i+1:]...)
|
|
break
|
|
}
|
|
}
|
|
|
|
nv := FileVersion{
|
|
Device: device,
|
|
Version: file.Version,
|
|
Invalid: file.IsInvalid(),
|
|
}
|
|
for i, v := range vl.Versions {
|
|
switch v.Version.Compare(file.Version) {
|
|
case protocol.Equal:
|
|
if nv.Invalid {
|
|
continue
|
|
}
|
|
fallthrough
|
|
|
|
case protocol.Lesser:
|
|
// The version at this point in the list is equal to or lesser
|
|
// ("older") than us. We insert ourselves in front of it.
|
|
vl = vl.insertAt(i, nv)
|
|
return vl, removedFV, removedAt, i
|
|
|
|
case protocol.ConcurrentLesser, protocol.ConcurrentGreater:
|
|
// The version at this point is in conflict with us. We must pull
|
|
// the actual file metadata to determine who wins. If we win, we
|
|
// insert ourselves in front of the loser here. (The "Lesser" and
|
|
// "Greater" in the condition above is just based on the device
|
|
// IDs in the version vector, which is not the only thing we use
|
|
// to determine the winner.)
|
|
//
|
|
// A surprise missing file entry here is counted as a win for us.
|
|
if of, ok := db.getFile(db.deviceKey(folder, v.Device, []byte(file.Name))); !ok || file.WinsConflict(of) {
|
|
vl = vl.insertAt(i, nv)
|
|
return vl, removedFV, removedAt, i
|
|
}
|
|
}
|
|
}
|
|
|
|
// We didn't find a position for an insert above, so append to the end.
|
|
vl.Versions = append(vl.Versions, nv)
|
|
|
|
return vl, removedFV, removedAt, len(vl.Versions) - 1
|
|
}
|
|
|
|
func (vl VersionList) insertAt(i int, v FileVersion) VersionList {
|
|
vl.Versions = append(vl.Versions, FileVersion{})
|
|
copy(vl.Versions[i+1:], vl.Versions[i:])
|
|
vl.Versions[i] = v
|
|
return vl
|
|
}
|
|
|
|
func (vl VersionList) Get(device []byte) (FileVersion, bool) {
|
|
for _, v := range vl.Versions {
|
|
if bytes.Equal(v.Device, device) {
|
|
return v, true
|
|
}
|
|
}
|
|
|
|
return FileVersion{}, false
|
|
}
|
|
|
|
type fileList []protocol.FileInfo
|
|
|
|
func (fl fileList) Len() int {
|
|
return len(fl)
|
|
}
|
|
|
|
func (fl fileList) Swap(a, b int) {
|
|
fl[a], fl[b] = fl[b], fl[a]
|
|
}
|
|
|
|
func (fl fileList) Less(a, b int) bool {
|
|
return fl[a].Name < fl[b].Name
|
|
}
|
|
|
|
// Flush batches to disk when they contain this many records.
|
|
const batchFlushSize = 64
|