You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
270 lines
5.4 KiB
270 lines
5.4 KiB
package db
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"sync"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
cmn "github.com/tendermint/tendermint/libs/common"
|
|
)
|
|
|
|
const (
|
|
keyPerm = os.FileMode(0600)
|
|
dirPerm = os.FileMode(0700)
|
|
)
|
|
|
|
func init() {
|
|
registerDBCreator(FSDBBackend, func(name string, dir string) (DB, error) {
|
|
dbPath := filepath.Join(dir, name+".db")
|
|
return NewFSDB(dbPath), nil
|
|
}, false)
|
|
}
|
|
|
|
var _ DB = (*FSDB)(nil)
|
|
|
|
// It's slow.
|
|
type FSDB struct {
|
|
mtx sync.Mutex
|
|
dir string
|
|
}
|
|
|
|
func NewFSDB(dir string) *FSDB {
|
|
err := os.MkdirAll(dir, dirPerm)
|
|
if err != nil {
|
|
panic(errors.Wrap(err, "Creating FSDB dir "+dir))
|
|
}
|
|
database := &FSDB{
|
|
dir: dir,
|
|
}
|
|
return database
|
|
}
|
|
|
|
func (db *FSDB) Get(key []byte) []byte {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
key = escapeKey(key)
|
|
|
|
path := db.nameToPath(key)
|
|
value, err := read(path)
|
|
if os.IsNotExist(err) {
|
|
return nil
|
|
} else if err != nil {
|
|
panic(errors.Wrapf(err, "Getting key %s (0x%X)", string(key), key))
|
|
}
|
|
return value
|
|
}
|
|
|
|
func (db *FSDB) Has(key []byte) bool {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
key = escapeKey(key)
|
|
|
|
path := db.nameToPath(key)
|
|
return cmn.FileExists(path)
|
|
}
|
|
|
|
func (db *FSDB) Set(key []byte, value []byte) {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
db.SetNoLock(key, value)
|
|
}
|
|
|
|
func (db *FSDB) SetSync(key []byte, value []byte) {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
db.SetNoLock(key, value)
|
|
}
|
|
|
|
// NOTE: Implements atomicSetDeleter.
|
|
func (db *FSDB) SetNoLock(key []byte, value []byte) {
|
|
key = escapeKey(key)
|
|
value = nonNilBytes(value)
|
|
path := db.nameToPath(key)
|
|
err := write(path, value)
|
|
if err != nil {
|
|
panic(errors.Wrapf(err, "Setting key %s (0x%X)", string(key), key))
|
|
}
|
|
}
|
|
|
|
func (db *FSDB) Delete(key []byte) {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
db.DeleteNoLock(key)
|
|
}
|
|
|
|
func (db *FSDB) DeleteSync(key []byte) {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
db.DeleteNoLock(key)
|
|
}
|
|
|
|
// NOTE: Implements atomicSetDeleter.
|
|
func (db *FSDB) DeleteNoLock(key []byte) {
|
|
key = escapeKey(key)
|
|
path := db.nameToPath(key)
|
|
err := remove(path)
|
|
if os.IsNotExist(err) {
|
|
return
|
|
} else if err != nil {
|
|
panic(errors.Wrapf(err, "Removing key %s (0x%X)", string(key), key))
|
|
}
|
|
}
|
|
|
|
func (db *FSDB) Close() {
|
|
// Nothing to do.
|
|
}
|
|
|
|
func (db *FSDB) Print() {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
panic("FSDB.Print not yet implemented")
|
|
}
|
|
|
|
func (db *FSDB) Stats() map[string]string {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
panic("FSDB.Stats not yet implemented")
|
|
}
|
|
|
|
func (db *FSDB) NewBatch() Batch {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
// Not sure we would ever want to try...
|
|
// It doesn't seem easy for general filesystems.
|
|
panic("FSDB.NewBatch not yet implemented")
|
|
}
|
|
|
|
func (db *FSDB) Mutex() *sync.Mutex {
|
|
return &(db.mtx)
|
|
}
|
|
|
|
func (db *FSDB) Iterator(start, end []byte) Iterator {
|
|
return db.MakeIterator(start, end, false)
|
|
}
|
|
|
|
func (db *FSDB) MakeIterator(start, end []byte, isReversed bool) Iterator {
|
|
db.mtx.Lock()
|
|
defer db.mtx.Unlock()
|
|
|
|
// We need a copy of all of the keys.
|
|
// Not the best, but probably not a bottleneck depending.
|
|
keys, err := list(db.dir, start, end)
|
|
if err != nil {
|
|
panic(errors.Wrapf(err, "Listing keys in %s", db.dir))
|
|
}
|
|
if isReversed {
|
|
sort.Sort(sort.Reverse(sort.StringSlice(keys)))
|
|
} else {
|
|
sort.Strings(keys)
|
|
}
|
|
return newMemDBIterator(db, keys, start, end)
|
|
}
|
|
|
|
func (db *FSDB) ReverseIterator(start, end []byte) Iterator {
|
|
return db.MakeIterator(start, end, true)
|
|
}
|
|
|
|
func (db *FSDB) nameToPath(name []byte) string {
|
|
n := url.PathEscape(string(name))
|
|
return filepath.Join(db.dir, n)
|
|
}
|
|
|
|
// Read some bytes to a file.
|
|
// CONTRACT: returns os errors directly without wrapping.
|
|
func read(path string) ([]byte, error) {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
|
|
d, err := ioutil.ReadAll(f)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return d, nil
|
|
}
|
|
|
|
// Write some bytes from a file.
|
|
// CONTRACT: returns os errors directly without wrapping.
|
|
func write(path string, d []byte) error {
|
|
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, keyPerm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
// fInfo, err := f.Stat()
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// if fInfo.Mode() != keyPerm {
|
|
// return tmerrors.NewErrPermissionsChanged(f.Name(), keyPerm, fInfo.Mode())
|
|
// }
|
|
_, err = f.Write(d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = f.Sync()
|
|
return err
|
|
}
|
|
|
|
// Remove a file.
|
|
// CONTRACT: returns os errors directly without wrapping.
|
|
func remove(path string) error {
|
|
return os.Remove(path)
|
|
}
|
|
|
|
// List keys in a directory, stripping of escape sequences and dir portions.
|
|
// CONTRACT: returns os errors directly without wrapping.
|
|
func list(dirPath string, start, end []byte) ([]string, error) {
|
|
dir, err := os.Open(dirPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer dir.Close()
|
|
|
|
names, err := dir.Readdirnames(0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var keys []string
|
|
for _, name := range names {
|
|
n, err := url.PathUnescape(name)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Failed to unescape %s while listing", name)
|
|
}
|
|
key := unescapeKey([]byte(n))
|
|
if IsKeyInDomain(key, start, end) {
|
|
keys = append(keys, string(key))
|
|
}
|
|
}
|
|
return keys, nil
|
|
}
|
|
|
|
// To support empty or nil keys, while the file system doesn't allow empty
|
|
// filenames.
|
|
func escapeKey(key []byte) []byte {
|
|
return []byte("k_" + string(key))
|
|
}
|
|
func unescapeKey(escKey []byte) []byte {
|
|
if len(escKey) < 2 {
|
|
panic(fmt.Sprintf("Invalid esc key: %x", escKey))
|
|
}
|
|
if string(escKey[:2]) != "k_" {
|
|
panic(fmt.Sprintf("Invalid esc key: %x", escKey))
|
|
}
|
|
return escKey[2:]
|
|
}
|