restic/backend/generic.go

129 lines
2.3 KiB
Go
Raw Normal View History

2014-09-23 20:39:12 +00:00
package backend
import (
"bytes"
"crypto/sha256"
"encoding/hex"
"errors"
"sort"
2014-09-23 20:39:12 +00:00
)
const (
MinPrefixLength = 4
)
var (
ErrNoIDPrefixFound = errors.New("no ID found")
ErrMultipleIDMatches = errors.New("multiple IDs with prefix found")
)
2015-02-11 18:25:43 +00:00
var (
newHash = sha256.New
hashData = sha256.Sum256
)
const hashSize = sha256.Size
2014-09-23 20:39:12 +00:00
// Each lists all entries of type t in the backend and calls function f() with
// the id.
2014-12-21 16:02:49 +00:00
func EachID(be Lister, t Type, f func(ID)) error {
2014-09-23 20:39:12 +00:00
ids, err := be.List(t)
if err != nil {
return err
}
for _, id := range ids {
f(id)
}
return nil
}
// Hash returns the ID for data.
func Hash(data []byte) ID {
2015-02-11 18:25:43 +00:00
h := hashData(data)
id := idPool.Get().(ID)
2014-09-23 20:39:12 +00:00
copy(id, h[:])
return id
}
// Find loads the list of all blobs of type t and searches for IDs which start
// with prefix. If none is found, nil and ErrNoIDPrefixFound is returned. If
// more than one is found, nil and ErrMultipleIDMatches is returned.
2014-12-21 16:02:49 +00:00
func Find(be Lister, t Type, prefix string) (ID, error) {
p, err := hex.DecodeString(prefix)
if err != nil {
return nil, err
}
list, err := be.List(t)
if err != nil {
return nil, err
}
match := ID(nil)
// TODO: optimize by sorting list etc.
for _, id := range list {
if bytes.Equal(p, id[:len(p)]) {
if match == nil {
match = id
} else {
return nil, ErrMultipleIDMatches
}
}
}
if match != nil {
return match, nil
}
return nil, ErrNoIDPrefixFound
}
// FindSnapshot takes a string and tries to find a snapshot whose ID matches
// the string as closely as possible.
2014-12-21 16:02:49 +00:00
func FindSnapshot(be Lister, s string) (ID, error) {
// parse ID directly
if id, err := ParseID(s); err == nil {
return id, nil
}
// find snapshot id with prefix
id, err := Find(be, Snapshot, s)
if err != nil {
return nil, err
}
return id, nil
}
// PrefixLength returns the number of bytes required so that all prefixes of
// all IDs of type t are unique.
2014-12-21 16:02:49 +00:00
func PrefixLength(be Lister, t Type) (int, error) {
// load all IDs of the given type
list, err := be.List(t)
if err != nil {
return 0, err
}
sort.Sort(list)
// select prefixes of length l, test if the last one is the same as the current one
outer:
for l := MinPrefixLength; l < IDSize; l++ {
var last ID
for _, id := range list {
if bytes.Equal(last, id[:l]) {
continue outer
}
last = id[:l]
}
return l, nil
}
return IDSize, nil
}