693d9ccbfb
* ethdb: remove Set Set deadlocks immediately and isn't part of the Database interface. * trie: add Err to Iterator This is useful for testing because the underlying NodeIterator doesn't need to be kept in a separate variable just to get the error. * trie: add LeafKey to iterator, panic when not at leaf LeafKey is useful for callers that can't interpret Path. * trie: retry failed seek/peek in iterator Next Instead of failing iteration irrecoverably, make it so Next retries the pending seek or peek every time. Smaller changes in this commit make this easier to test: * The iterator previously returned from Next on encountering a hash node. This caused it to visit the same path twice. * Path returned nibbles with terminator symbol for valueNode attached to fullNode, but removed it for valueNode attached to shortNode. Now the terminator is always present. This makes Path unique to each node and simplifies Leaf. * trie: add Path to MissingNodeError The light client trie iterator needs to know the path of the node that's missing so it can retrieve a proof for it. NodeIterator.Path is not sufficient because it is updated when the node is resolved and actually visited by the iterator. Also remove unused fields. They were added a long time ago before we knew which fields would be needed for the light client.
119 lines
2.5 KiB
Go
119 lines
2.5 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package ethdb
|
|
|
|
import (
|
|
"errors"
|
|
"sync"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
)
|
|
|
|
/*
|
|
* This is a test memory database. Do not use for any production it does not get persisted
|
|
*/
|
|
type MemDatabase struct {
|
|
db map[string][]byte
|
|
lock sync.RWMutex
|
|
}
|
|
|
|
func NewMemDatabase() (*MemDatabase, error) {
|
|
return &MemDatabase{
|
|
db: make(map[string][]byte),
|
|
}, nil
|
|
}
|
|
|
|
func (db *MemDatabase) Put(key []byte, value []byte) error {
|
|
db.lock.Lock()
|
|
defer db.lock.Unlock()
|
|
|
|
db.db[string(key)] = common.CopyBytes(value)
|
|
return nil
|
|
}
|
|
|
|
func (db *MemDatabase) Get(key []byte) ([]byte, error) {
|
|
db.lock.RLock()
|
|
defer db.lock.RUnlock()
|
|
|
|
if entry, ok := db.db[string(key)]; ok {
|
|
return entry, nil
|
|
}
|
|
return nil, errors.New("not found")
|
|
}
|
|
|
|
func (db *MemDatabase) Keys() [][]byte {
|
|
db.lock.RLock()
|
|
defer db.lock.RUnlock()
|
|
|
|
keys := [][]byte{}
|
|
for key := range db.db {
|
|
keys = append(keys, []byte(key))
|
|
}
|
|
return keys
|
|
}
|
|
|
|
/*
|
|
func (db *MemDatabase) GetKeys() []*common.Key {
|
|
data, _ := db.Get([]byte("KeyRing"))
|
|
|
|
return []*common.Key{common.NewKeyFromBytes(data)}
|
|
}
|
|
*/
|
|
|
|
func (db *MemDatabase) Delete(key []byte) error {
|
|
db.lock.Lock()
|
|
defer db.lock.Unlock()
|
|
|
|
delete(db.db, string(key))
|
|
return nil
|
|
}
|
|
|
|
func (db *MemDatabase) Close() {}
|
|
|
|
func (db *MemDatabase) NewBatch() Batch {
|
|
return &memBatch{db: db}
|
|
}
|
|
|
|
type kv struct{ k, v []byte }
|
|
|
|
type memBatch struct {
|
|
db *MemDatabase
|
|
writes []kv
|
|
lock sync.RWMutex
|
|
}
|
|
|
|
func (b *memBatch) Put(key, value []byte) error {
|
|
b.lock.Lock()
|
|
defer b.lock.Unlock()
|
|
|
|
b.writes = append(b.writes, kv{common.CopyBytes(key), common.CopyBytes(value)})
|
|
return nil
|
|
}
|
|
|
|
func (b *memBatch) Write() error {
|
|
b.lock.RLock()
|
|
defer b.lock.RUnlock()
|
|
|
|
b.db.lock.Lock()
|
|
defer b.db.lock.Unlock()
|
|
|
|
for _, kv := range b.writes {
|
|
b.db.db[string(kv.k)] = kv.v
|
|
}
|
|
return nil
|
|
}
|