"strings"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/crypto/sha3pool"
"github.com/bytom/errors"
+ dbm "github.com/bytom/database/leveldb"
)
const tokenSize = 32
"strings"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/errors"
+ dbm "github.com/bytom/database/leveldb"
)
func TestCreate(t *testing.T) {
"github.com/golang/groupcache/lru"
log "github.com/sirupsen/logrus"
- dbm "github.com/tendermint/tmlibs/db"
"github.com/bytom/blockchain/signers"
"github.com/bytom/blockchain/txbuilder"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/vm/vmutil"
+ dbm "github.com/bytom/database/leveldb"
)
const (
"strings"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/blockchain/signers"
"github.com/bytom/crypto/ed25519/chainkd"
- "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
"github.com/bytom/errors"
"github.com/bytom/event"
"github.com/bytom/protocol"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestCreateAccountWithUppercase(t *testing.T) {
testDB := dbm.NewDB("testdb", "memdb", dirPath)
dispatcher := event.NewDispatcher()
- store := leveldb.NewStore(testDB)
+ store := database.NewStore(testDB)
txPool := protocol.NewTxPool(store, dispatcher)
chain, err := protocol.NewChain(store, txPool)
if err != nil {
"time"
log "github.com/sirupsen/logrus"
- dbm "github.com/tendermint/tmlibs/db"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
+ dbm "github.com/bytom/database/leveldb"
)
const desireUtxoCount = 5
"testing"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/protocol/bc"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestAddUnconfirmedUtxo(t *testing.T) {
"os"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/accesstoken"
"github.com/bytom/blockchain/rpc"
"github.com/bytom/blockchain/txbuilder"
"github.com/bytom/consensus"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestAPIHandler(t *testing.T) {
"sync"
"github.com/golang/groupcache/lru"
- dbm "github.com/tendermint/tmlibs/db"
"golang.org/x/crypto/sha3"
"github.com/bytom/blockchain/signers"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/vm/vmutil"
+ dbm "github.com/bytom/database/leveldb"
)
// DefaultNativeAsset native BTM asset
"strings"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/consensus"
"github.com/bytom/crypto/ed25519/chainkd"
- "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
"github.com/bytom/event"
"github.com/bytom/protocol"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestDefineAssetWithLowercase(t *testing.T) {
}
func mockChain(testDB dbm.DB) (*protocol.Chain, error) {
- store := leveldb.NewStore(testDB)
+ store := database.NewStore(testDB)
dispatcher := event.NewDispatcher()
txPool := protocol.NewTxPool(store, dispatcher)
chain, err := protocol.NewChain(store, txPool)
"strings"
log "github.com/sirupsen/logrus"
- dbm "github.com/tendermint/tmlibs/db"
"github.com/bytom/blockchain/query"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/vm/vmutil"
+ dbm "github.com/bytom/database/leveldb"
)
const (
-package leveldb
+package database
import (
"fmt"
-package leveldb
+package database
import (
"testing"
Key() []byte
Value() []byte
+ Seek([]byte) bool
Release()
Error() error
return v
}
+func (it *goLevelDBIterator) Seek(point []byte) bool {
+ return it.source.Seek(point)
+}
+
func (it *goLevelDBIterator) Error() error {
return it.source.Error()
}
return it.db.Get(it.Key())
}
+func (it *memDBIterator) Seek(point []byte) bool {
+ for i, key := range it.keys {
+ if key >= string(point) {
+ it.last = i
+ return true
+ }
+ }
+ return false
+}
+
func (it *memDBIterator) Release() {
it.db = nil
it.keys = nil
-package leveldb
+package database
import (
"encoding/binary"
"github.com/golang/protobuf/proto"
log "github.com/sirupsen/logrus"
"github.com/tendermint/tmlibs/common"
- dbm "github.com/tendermint/tmlibs/db"
"github.com/bytom/database/storage"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/state"
+ dbm "github.com/bytom/database/leveldb"
)
const logModule = "leveldb"
-package leveldb
+package database
import (
"os"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/config"
"github.com/bytom/database/storage"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/state"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestLoadBlockIndex(t *testing.T) {
-package leveldb
+package database
import (
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/database/storage"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/state"
"github.com/golang/protobuf/proto"
+ dbm "github.com/bytom/database/leveldb"
)
const utxoPreFix = "UT:"
-package leveldb
+package database
import (
"os"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/database/storage"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/state"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestSaveUtxoView(t *testing.T) {
"strings"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/accesstoken"
"github.com/bytom/errors"
+ dbm "github.com/bytom/database/leveldb"
)
func TestAuthenticate(t *testing.T) {
"github.com/prometheus/prometheus/util/flock"
log "github.com/sirupsen/logrus"
cmn "github.com/tendermint/tmlibs/common"
- dbm "github.com/tendermint/tmlibs/db"
browser "github.com/toqueteos/webbrowser"
"github.com/bytom/accesstoken"
"github.com/bytom/blockchain/txfeed"
cfg "github.com/bytom/config"
"github.com/bytom/consensus"
- "github.com/bytom/database/leveldb"
"github.com/bytom/env"
"github.com/bytom/event"
"github.com/bytom/mining/cpuminer"
"github.com/bytom/p2p"
"github.com/bytom/protocol"
w "github.com/bytom/wallet"
+ dbm "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
)
const (
cmn.Exit(cmn.Fmt("Param db_backend [%v] is invalid, use leveldb or memdb", config.DBBackend))
}
coreDB := dbm.NewDB("core", config.DBBackend, config.DBDir())
- store := leveldb.NewStore(coreDB)
+ store := database.NewStore(coreDB)
tokenDB := dbm.NewDB("accesstoken", config.DBBackend, config.DBDir())
accessTokens := accesstoken.NewStore(tokenDB)
"bytes"
"crypto/rand"
"encoding/binary"
- "fmt"
"os"
+ "path"
"sync"
"time"
log "github.com/sirupsen/logrus"
- "github.com/syndtr/goleveldb/leveldb"
- "github.com/syndtr/goleveldb/leveldb/errors"
- "github.com/syndtr/goleveldb/leveldb/iterator"
- "github.com/syndtr/goleveldb/leveldb/opt"
- "github.com/syndtr/goleveldb/leveldb/storage"
- "github.com/syndtr/goleveldb/leveldb/util"
- "github.com/tendermint/go-wire"
+ wire "github.com/tendermint/go-wire"
"github.com/bytom/crypto"
+ dbm "github.com/bytom/database/leveldb"
+ "github.com/bytom/errors"
)
var (
// nodeDB stores all nodes we know about.
type nodeDB struct {
- lvl *leveldb.DB // Interface to the database itself
+ lvl dbm.DB // Interface to the database itself
self NodeID // Own node id to prevent adding it into the database
runner sync.Once // Ensures we can start at most one expirer
quit chan struct{} // Channel to signal the expiring thread to stop
// database is constructed.
func newNodeDB(path string, version int, self NodeID) (*nodeDB, error) {
if path == "" {
- return newMemoryNodeDB(self)
+ return newMemoryNodeDB(self), nil
}
return newPersistentNodeDB(path, version, self)
}
// newMemoryNodeDB creates a new in-memory node database without a persistent
// backend.
-func newMemoryNodeDB(self NodeID) (*nodeDB, error) {
- db, err := leveldb.Open(storage.NewMemStorage(), nil)
- if err != nil {
- return nil, err
- }
+func newMemoryNodeDB(self NodeID) *nodeDB {
+ db := dbm.NewMemDB()
return &nodeDB{
lvl: db,
self: self,
quit: make(chan struct{}),
- }, nil
+ }
}
// newPersistentNodeDB creates/opens a leveldb backed persistent node database,
// also flushing its contents in case of a version mismatch.
-func newPersistentNodeDB(path string, version int, self NodeID) (*nodeDB, error) {
- opts := &opt.Options{OpenFilesCacheCapacity: 5}
- db, err := leveldb.OpenFile(path, opts)
- if _, iscorrupted := err.(*errors.ErrCorrupted); iscorrupted {
- db, err = leveldb.RecoverFile(path, nil)
- }
- if err != nil {
- return nil, err
+func newPersistentNodeDB(filePath string, version int, self NodeID) (*nodeDB, error) {
+ dir, file := path.Split(filePath)
+ if file == "" {
+ return nil, errors.New("unspecified db file name")
}
+ db := dbm.NewDB(file, dbm.GoLevelDBBackendStr, dir)
+
// The nodes contained in the cache correspond to a certain protocol version.
// Flush all nodes if the version doesn't match.
currentVer := make([]byte, binary.MaxVarintLen64)
currentVer = currentVer[:binary.PutVarint(currentVer, int64(version))]
- blob, err := db.Get(nodeDBVersionKey, nil)
- switch err {
- case leveldb.ErrNotFound:
- // Version not found (i.e. empty cache), insert it
- if err = db.Put(nodeDBVersionKey, currentVer, nil); err != nil {
- if err := db.Close(); err != nil {
- log.WithFields(log.Fields{"module": logModule, "error": err}).Warn(fmt.Sprintf("db close err"))
- }
+ blob := db.Get(nodeDBVersionKey)
+ if blob == nil {
+ db.Set(nodeDBVersionKey, currentVer)
+ } else if !bytes.Equal(blob, currentVer) {
+ db.Close()
+ if err := os.RemoveAll(filePath + ".db"); err != nil {
return nil, err
}
-
- case nil:
- // Version present, flush if different
- if !bytes.Equal(blob, currentVer) {
- if err = db.Close(); err != nil {
- log.WithFields(log.Fields{"module": logModule, "error": err}).Warn(fmt.Sprintf("db close err"))
- }
- if err = os.RemoveAll(path); err != nil {
- return nil, err
- }
- return newPersistentNodeDB(path, version, self)
- }
+ return newPersistentNodeDB(filePath, version, self)
}
+
return &nodeDB{
lvl: db,
self: self,
// fetchInt64 retrieves an integer instance associated with a particular
// database key.
func (db *nodeDB) fetchInt64(key []byte) int64 {
- blob, err := db.lvl.Get(key, nil)
- if err != nil {
+ blob := db.lvl.Get(key)
+ if blob == nil {
return 0
}
val, read := binary.Varint(blob)
// storeInt64 update a specific database entry to the current time instance as a
// unix timestamp.
-func (db *nodeDB) storeInt64(key []byte, n int64) error {
+func (db *nodeDB) storeInt64(key []byte, n int64) {
blob := make([]byte, binary.MaxVarintLen64)
blob = blob[:binary.PutVarint(blob, n)]
- return db.lvl.Put(key, blob, nil)
+ db.lvl.Set(key, blob)
}
// node retrieves a node with a given id from the database.
)
key := makeKey(id, nodeDBDiscoverRoot)
- rawData, err := db.lvl.Get(key, nil)
- if err != nil {
- log.WithFields(log.Fields{"module": logModule, "error": err}).Warn(fmt.Sprintf("get node rawdata err"))
- return nil
- }
+ rawData := db.lvl.Get(key)
+ var err error
wire.ReadBinary(node, bytes.NewReader(rawData), 0, &n, &err)
if err != nil {
log.WithFields(log.Fields{"module": logModule, "key": key, "node": node, "error": err}).Warn("get node from db err")
return err
}
- return db.lvl.Put(makeKey(node.ID, nodeDBDiscoverRoot), blob.Bytes(), nil)
+ db.lvl.Set(makeKey(node.ID, nodeDBDiscoverRoot), blob.Bytes())
+ return nil
}
// deleteNode deletes all information/keys associated with a node.
-func (db *nodeDB) deleteNode(id NodeID) error {
- deleter := db.lvl.NewIterator(util.BytesPrefix(makeKey(id, "")), nil)
+func (db *nodeDB) deleteNode(id NodeID) {
+ deleter := db.lvl.IteratorPrefix(makeKey(id, ""))
for deleter.Next() {
- if err := db.lvl.Delete(deleter.Key(), nil); err != nil {
- return err
- }
+ db.lvl.Delete(deleter.Key())
}
- return nil
}
// ensureExpirer is a small helper method ensuring that the data expiration
threshold := time.Now().Add(-nodeDBNodeExpiration)
// Find discovered nodes that are older than the allowance
- it := db.lvl.NewIterator(nil, nil)
+ it := db.lvl.Iterator()
defer it.Release()
for it.Next() {
}
}
// Otherwise delete all associated information
- if err := db.deleteNode(id); err != nil {
- return err
- }
+ db.deleteNode(id)
}
return nil
}
// updateLastPing updates the last time we tried contacting a remote node.
-func (db *nodeDB) updateLastPing(id NodeID, instance time.Time) error {
- return db.storeInt64(makeKey(id, nodeDBDiscoverPing), instance.Unix())
+func (db *nodeDB) updateLastPing(id NodeID, instance time.Time) {
+ db.storeInt64(makeKey(id, nodeDBDiscoverPing), instance.Unix())
}
// lastPong retrieves the time of the last successful contact from remote node.
}
// updateLastPong updates the last time a remote node successfully contacted.
-func (db *nodeDB) updateLastPong(id NodeID, instance time.Time) error {
- return db.storeInt64(makeKey(id, nodeDBDiscoverPong), instance.Unix())
+func (db *nodeDB) updateLastPong(id NodeID, instance time.Time) {
+ db.storeInt64(makeKey(id, nodeDBDiscoverPong), instance.Unix())
}
// findFails retrieves the number of findnode failures since bonding.
}
// updateFindFails updates the number of findnode failures since bonding.
-func (db *nodeDB) updateFindFails(id NodeID, fails int) error {
- return db.storeInt64(makeKey(id, nodeDBDiscoverFindFails), int64(fails))
+func (db *nodeDB) updateFindFails(id NodeID, fails int) {
+ db.storeInt64(makeKey(id, nodeDBDiscoverFindFails), int64(fails))
}
// querySeeds retrieves random nodes to be used as potential seed nodes
var (
now = time.Now()
nodes = make([]*Node, 0, n)
- it = db.lvl.NewIterator(nil, nil)
+ it = db.lvl.Iterator()
id NodeID
)
defer it.Release()
func (db *nodeDB) fetchTopicRegTickets(id NodeID) (issued, used uint32) {
key := makeKey(id, nodeDBTopicRegTickets)
- blob, err := db.lvl.Get(key, nil)
- if err != nil {
- log.WithFields(log.Fields{"module": logModule, "error": err}).Warn("db get raw data")
- }
+ blob := db.lvl.Get(key)
if len(blob) != 8 {
return 0, 0
return
}
-func (db *nodeDB) updateTopicRegTickets(id NodeID, issued, used uint32) error {
+func (db *nodeDB) updateTopicRegTickets(id NodeID, issued, used uint32) {
key := makeKey(id, nodeDBTopicRegTickets)
blob := make([]byte, 8)
binary.BigEndian.PutUint32(blob[0:4], issued)
binary.BigEndian.PutUint32(blob[4:8], used)
- return db.lvl.Put(key, blob, nil)
+ db.lvl.Set(key, blob)
}
// reads the next node record from the iterator, skipping over other
// database entries.
-func nextNode(it iterator.Iterator) *Node {
+func nextNode(it dbm.Iterator) *Node {
var (
n = int(0)
err = error(nil)
// close flushes and closes the database files.
func (db *nodeDB) close() {
close(db.quit)
- if err := db.lvl.Close(); err != nil {
- log.WithFields(log.Fields{"module": logModule, "error": err}).Warn("db close err")
- }
+ db.lvl.Close()
}
tests := nodeDBInt64Tests
for i := 0; i < len(tests); i++ {
// Insert the next value
- if err := db.storeInt64(tests[i].key, tests[i].value); err != nil {
- t.Errorf("test %d: failed to store value: %v", i, err)
- }
+ db.storeInt64(tests[i].key, tests[i].value)
+
// Check all existing and non existing values
for j := 0; j < len(tests); j++ {
num := db.fetchInt64(tests[j].key)
if stored := db.lastPing(node.ID); stored.Unix() != 0 {
t.Errorf("ping: non-existing object: %v", stored)
}
- if err := db.updateLastPing(node.ID, inst); err != nil {
- t.Errorf("ping: failed to update: %v", err)
- }
+ db.updateLastPing(node.ID, inst)
+
if stored := db.lastPing(node.ID); stored.Unix() != inst.Unix() {
t.Errorf("ping: value mismatch: have %v, want %v", stored, inst)
}
if stored := db.lastPong(node.ID); stored.Unix() != 0 {
t.Errorf("pong: non-existing object: %v", stored)
}
- if err := db.updateLastPong(node.ID, inst); err != nil {
- t.Errorf("pong: failed to update: %v", err)
- }
+ db.updateLastPong(node.ID, inst)
+
if stored := db.lastPong(node.ID); stored.Unix() != inst.Unix() {
t.Errorf("pong: value mismatch: have %v, want %v", stored, inst)
}
if stored := db.findFails(node.ID); stored != 0 {
t.Errorf("find-node fails: non-existing object: %v", stored)
}
- if err := db.updateFindFails(node.ID, num); err != nil {
- t.Errorf("find-node fails: failed to update: %v", err)
- }
+ db.updateFindFails(node.ID, num)
+
if stored := db.findFails(node.ID); stored != num {
t.Errorf("find-node fails: value mismatch: have %v, want %v", stored, num)
}
if err := db.updateNode(seed.node); err != nil {
t.Fatalf("node %d: failed to insert: %v", i, err)
}
- if err := db.updateLastPong(seed.node.ID, seed.pong); err != nil {
- t.Fatalf("node %d: failed to insert lastPong: %v", i, err)
- }
+ db.updateLastPong(seed.node.ID, seed.pong)
}
// Retrieve the entire batch and check for duplicates
if err != nil {
t.Fatalf("failed to create persistent database: %v", err)
}
- if err = db.storeInt64(testKey, testInt); err != nil {
- t.Fatalf("failed to store value: %v.", err)
- }
+ db.storeInt64(testKey, testInt)
db.close()
// Reopen the database and check the value
if err := db.updateNode(seed.node); err != nil {
t.Fatalf("node %d: failed to insert: %v", i, err)
}
- if err := db.updateLastPong(seed.node.ID, seed.pong); err != nil {
- t.Fatalf("node %d: failed to update pong: %v", i, err)
- }
+ db.updateLastPong(seed.node.ID, seed.pong)
}
// Expire some of them, and check the rest
if err := db.expireNodes(); err != nil {
if err := db.updateNode(seed.node); err != nil {
t.Fatalf("node %d: failed to insert: %v", i, err)
}
- if err := db.updateLastPong(seed.node.ID, seed.pong); err != nil {
- t.Fatalf("node %d: failed to update pong: %v", i, err)
- }
+ db.updateLastPong(seed.node.ID, seed.pong)
}
// Expire the nodes and make sure self has been evacuated too
if err := db.expireNodes(); err != nil {
}
for _, v := range topicRegTicketsTests {
- if err := db.updateTopicRegTickets(v.id, v.issued, v.used); err != nil {
- t.Fatalf("failed to update topic reg ticktes: %v", err)
- }
+ db.updateTopicRegTickets(v.id, v.issued, v.used)
issued, used := db.fetchTopicRegTickets(v.id)
if issued != v.issued {
name: "unresponsive",
canQuery: true,
handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) {
- if err := net.db.deleteNode(n.ID); err != nil {
- return known, err
- }
+ net.db.deleteNode(n.ID)
switch ev {
case pingPacket:
}
n.pingEcho = nil
n.pingTopics = nil
- if err = net.db.updateLastPong(n.ID, time.Now()); err != nil {
- return err
- }
+ net.db.updateLastPong(n.ID, time.Now())
return err
}
}
realaddr := conn.LocalAddr().(*net.UDPAddr)
- ntab, err := ListenUDP(priv, conn, realaddr, path.Join(config.DBDir(), "discover.db"), nil)
+ ntab, err := ListenUDP(priv, conn, realaddr, path.Join(config.DBDir(), "discover"), nil)
if err != nil {
return nil, err
}
log "github.com/sirupsen/logrus"
"github.com/tendermint/go-crypto"
cmn "github.com/tendermint/tmlibs/common"
- dbm "github.com/tendermint/tmlibs/db"
cfg "github.com/bytom/config"
"github.com/bytom/consensus"
"github.com/bytom/p2p/netutil"
"github.com/bytom/p2p/trust"
"github.com/bytom/version"
+ dbm "github.com/bytom/database/leveldb"
)
const (
import (
"github.com/tendermint/go-crypto"
- dbm "github.com/tendermint/tmlibs/db"
"io/ioutil"
"os"
"sync"
cfg "github.com/bytom/config"
"github.com/bytom/errors"
conn "github.com/bytom/p2p/connection"
+ dbm "github.com/bytom/database/leveldb"
)
var (
log "github.com/sirupsen/logrus"
"github.com/tendermint/go-crypto"
cmn "github.com/tendermint/tmlibs/common"
- dbm "github.com/tendermint/tmlibs/db"
cfg "github.com/bytom/config"
"github.com/bytom/errors"
"github.com/bytom/p2p/connection"
"github.com/bytom/p2p/discover"
+ dbm "github.com/bytom/database/leveldb"
)
//PanicOnAddPeerErr add peer error
"testing"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/blockchain/signers"
"github.com/bytom/consensus"
"github.com/bytom/consensus/difficulty"
"github.com/bytom/crypto/ed25519/chainkd"
- "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
"github.com/bytom/database/storage"
"github.com/bytom/event"
"github.com/bytom/mining"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/state"
+ dbm "github.com/bytom/database/leveldb"
)
func BenchmarkChain_CoinBaseTx_NoAsset(b *testing.B) {
return nil, nil, nil, err
}
- store := leveldb.NewStore(testDB)
+ store := database.NewStore(testDB)
dispatcher := event.NewDispatcher()
txPool := protocol.NewTxPool(store, dispatcher)
chain, err := protocol.NewChain(store, txPool)
func SetUtxoView(db dbm.DB, view *state.UtxoViewpoint) error {
batch := db.NewBatch()
- if err := leveldb.SaveUtxoView(batch, view); err != nil {
+ if err := database.SaveUtxoView(batch, view); err != nil {
return err
}
batch.Write()
"testing"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/consensus"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/vm"
+ dbm "github.com/bytom/database/leveldb"
)
func TestBlockHeader(t *testing.T) {
"os"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/blockchain/txbuilder"
"github.com/bytom/consensus"
- "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
"github.com/bytom/database/storage"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/vm"
"github.com/golang/protobuf/proto"
+ dbm "github.com/bytom/database/leveldb"
)
const utxoPrefix = "UT:"
type chainTestContext struct {
Chain *protocol.Chain
DB dbm.DB
- Store *leveldb.Store
+ Store *database.Store
}
func (ctx *chainTestContext) validateStatus(block *types.Block) error {
"os"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/blockchain/signers"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/validation"
"github.com/bytom/test"
+ dbm "github.com/bytom/database/leveldb"
)
func TestP2PKH(t *testing.T) {
"os"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/mining"
"github.com/bytom/test"
+ dbm "github.com/bytom/database/leveldb"
)
// Function NewBlockTemplate's benchmark - 0.05s
"os"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/consensus"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/vm"
+ dbm "github.com/bytom/database/leveldb"
)
// case1: |------c1(height=7)
import (
"fmt"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc/types"
+ dbm "github.com/bytom/database/leveldb"
)
func declChain(name string, baseChain *protocol.Chain, baseHeight uint64, height uint64) (*protocol.Chain, error) {
"testing"
log "github.com/sirupsen/logrus"
- dbm "github.com/tendermint/tmlibs/db"
"github.com/bytom/account"
"github.com/bytom/asset"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/validation"
"github.com/bytom/protocol/vm"
+ dbm "github.com/bytom/database/leveldb"
)
func init() {
"fmt"
"time"
- "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/asset"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/vm"
"github.com/bytom/protocol/vm/vmutil"
+ dbm "github.com/bytom/database/leveldb"
)
// TxGenerator used to generate new tx
}
// SignInstructionFor read CtrlProgram from db, construct SignInstruction for SpendInput
-func SignInstructionFor(input *types.SpendInput, db db.DB, signer *signers.Signer) (*txbuilder.SigningInstruction, error) {
+func SignInstructionFor(input *types.SpendInput, db dbm.DB, signer *signers.Signer) (*txbuilder.SigningInstruction, error) {
cp := account.CtrlProgram{}
var hash [32]byte
sha3pool.Sum256(hash[:], input.ControlProgram)
"context"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/blockchain/txbuilder"
"github.com/bytom/consensus"
"github.com/bytom/crypto/ed25519/chainkd"
- "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
"github.com/bytom/event"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/vm"
+ dbm "github.com/bytom/database/leveldb"
)
const (
)
// MockChain mock chain with genesis block
-func MockChain(testDB dbm.DB) (*protocol.Chain, *leveldb.Store, *protocol.TxPool, error) {
- store := leveldb.NewStore(testDB)
+func MockChain(testDB dbm.DB) (*protocol.Chain, *database.Store, *protocol.TxPool, error) {
+ store := database.NewStore(testDB)
dispatcher := event.NewDispatcher()
txPool := protocol.NewTxPool(store, dispatcher)
chain, err := protocol.NewChain(store, txPool)
"github.com/bytom/testutil"
"github.com/golang/protobuf/proto"
- dbm "github.com/tendermint/tmlibs/db"
- "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
"github.com/bytom/database/storage"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/state"
+ dbm "github.com/bytom/database/leveldb"
)
func TestAttachOrDetachBlocks(t *testing.T) {
defer os.RemoveAll("temp")
for index, c := range cases {
testDB := dbm.NewDB("testdb", "leveldb", "temp")
- store := leveldb.NewStore(testDB)
+ store := database.NewStore(testDB)
utxoViewpoint := state.NewUtxoViewpoint()
for k, v := range c.before {
"path"
"reflect"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/asset"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc/types"
w "github.com/bytom/wallet"
+ dbm "github.com/bytom/database/leveldb"
)
type walletTestConfig struct {
+++ /dev/null
-// +build gcc
-
-package db
-
-import (
- "fmt"
- "path"
-
- "github.com/jmhodges/levigo"
-
- . "github.com/tendermint/tmlibs/common"
-)
-
-func init() {
- dbCreator := func(name string, dir string) (DB, error) {
- return NewCLevelDB(name, dir)
- }
- registerDBCreator(LevelDBBackendStr, dbCreator, true)
- registerDBCreator(CLevelDBBackendStr, dbCreator, false)
-}
-
-type CLevelDB struct {
- db *levigo.DB
- ro *levigo.ReadOptions
- wo *levigo.WriteOptions
- woSync *levigo.WriteOptions
-}
-
-func NewCLevelDB(name string, dir string) (*CLevelDB, error) {
- dbPath := path.Join(dir, name+".db")
-
- opts := levigo.NewOptions()
- opts.SetCache(levigo.NewLRUCache(1 << 30))
- opts.SetCreateIfMissing(true)
- db, err := levigo.Open(dbPath, opts)
- if err != nil {
- return nil, err
- }
- ro := levigo.NewReadOptions()
- wo := levigo.NewWriteOptions()
- woSync := levigo.NewWriteOptions()
- woSync.SetSync(true)
- database := &CLevelDB{
- db: db,
- ro: ro,
- wo: wo,
- woSync: woSync,
- }
- return database, nil
-}
-
-func (db *CLevelDB) Get(key []byte) []byte {
- res, err := db.db.Get(db.ro, key)
- if err != nil {
- PanicCrisis(err)
- }
- return res
-}
-
-func (db *CLevelDB) Set(key []byte, value []byte) {
- err := db.db.Put(db.wo, key, value)
- if err != nil {
- PanicCrisis(err)
- }
-}
-
-func (db *CLevelDB) SetSync(key []byte, value []byte) {
- err := db.db.Put(db.woSync, key, value)
- if err != nil {
- PanicCrisis(err)
- }
-}
-
-func (db *CLevelDB) Delete(key []byte) {
- err := db.db.Delete(db.wo, key)
- if err != nil {
- PanicCrisis(err)
- }
-}
-
-func (db *CLevelDB) DeleteSync(key []byte) {
- err := db.db.Delete(db.woSync, key)
- if err != nil {
- PanicCrisis(err)
- }
-}
-
-func (db *CLevelDB) DB() *levigo.DB {
- return db.db
-}
-
-func (db *CLevelDB) Close() {
- db.db.Close()
- db.ro.Close()
- db.wo.Close()
- db.woSync.Close()
-}
-
-func (db *CLevelDB) Print() {
- iter := db.db.NewIterator(db.ro)
- defer iter.Close()
- for iter.Seek(nil); iter.Valid(); iter.Next() {
- key := iter.Key()
- value := iter.Value()
- fmt.Printf("[%X]:\t[%X]\n", key, value)
- }
-}
-
-func (db *CLevelDB) Stats() map[string]string {
- // TODO: Find the available properties for the C LevelDB implementation
- keys := []string{}
-
- stats := make(map[string]string)
- for _, key := range keys {
- str, err := db.db.GetProperty(key)
- if err == nil {
- stats[key] = str
- }
- }
- return stats
-}
-
-func (db *CLevelDB) Iterator() Iterator {
- return db.db.NewIterator(nil, nil)
-}
-
-func (db *CLevelDB) NewBatch() Batch {
- batch := levigo.NewWriteBatch()
- return &cLevelDBBatch{db, batch}
-}
-
-//--------------------------------------------------------------------------------
-
-type cLevelDBBatch struct {
- db *CLevelDB
- batch *levigo.WriteBatch
-}
-
-func (mBatch *cLevelDBBatch) Set(key, value []byte) {
- mBatch.batch.Put(key, value)
-}
-
-func (mBatch *cLevelDBBatch) Delete(key []byte) {
- mBatch.batch.Delete(key)
-}
-
-func (mBatch *cLevelDBBatch) Write() {
- err := mBatch.db.db.Write(mBatch.db.wo, mBatch.batch)
- if err != nil {
- PanicCrisis(err)
- }
-}
+++ /dev/null
-// +build gcc
-
-package db
-
-import (
- "bytes"
- "fmt"
- "testing"
-
- . "github.com/tendermint/tmlibs/common"
-)
-
-func BenchmarkRandomReadsWrites2(b *testing.B) {
- b.StopTimer()
-
- numItems := int64(1000000)
- internal := map[int64]int64{}
- for i := 0; i < int(numItems); i++ {
- internal[int64(i)] = int64(0)
- }
- db, err := NewCLevelDB(Fmt("test_%x", RandStr(12)), "")
- if err != nil {
- b.Fatal(err.Error())
- return
- }
-
- fmt.Println("ok, starting")
- b.StartTimer()
-
- for i := 0; i < b.N; i++ {
- // Write something
- {
- idx := (int64(RandInt()) % numItems)
- internal[idx] += 1
- val := internal[idx]
- idxBytes := int642Bytes(int64(idx))
- valBytes := int642Bytes(int64(val))
- //fmt.Printf("Set %X -> %X\n", idxBytes, valBytes)
- db.Set(
- idxBytes,
- valBytes,
- )
- }
- // Read something
- {
- idx := (int64(RandInt()) % numItems)
- val := internal[idx]
- idxBytes := int642Bytes(int64(idx))
- valBytes := db.Get(idxBytes)
- //fmt.Printf("Get %X -> %X\n", idxBytes, valBytes)
- if val == 0 {
- if !bytes.Equal(valBytes, nil) {
- b.Errorf("Expected %v for %v, got %X",
- nil, idx, valBytes)
- break
- }
- } else {
- if len(valBytes) != 8 {
- b.Errorf("Expected length 8 for %v, got %X",
- idx, valBytes)
- break
- }
- valGot := bytes2Int64(valBytes)
- if val != valGot {
- b.Errorf("Expected %v for %v, got %v",
- val, idx, valGot)
- break
- }
- }
- }
- }
-
- db.Close()
-}
-
-/*
-func int642Bytes(i int64) []byte {
- buf := make([]byte, 8)
- binary.BigEndian.PutUint64(buf, uint64(i))
- return buf
-}
-
-func bytes2Int64(buf []byte) int64 {
- return int64(binary.BigEndian.Uint64(buf))
-}
-*/
"fmt"
log "github.com/sirupsen/logrus"
- "github.com/tendermint/tmlibs/db"
"github.com/bytom/account"
"github.com/bytom/asset"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/protocol/vm/vmutil"
+ dbm "github.com/bytom/database/leveldb"
)
// annotateTxs adds asset data to transactions
}
// annotateTxs adds account data to transactions
-func annotateTxsAccount(txs []*query.AnnotatedTx, walletDB db.DB) {
+func annotateTxsAccount(txs []*query.AnnotatedTx, walletDB dbm.DB) {
for i, tx := range txs {
for j, input := range tx.Inputs {
//issue asset tx input SpentOutputID is nil
}
}
-func getAccountFromACP(program []byte, walletDB db.DB) (*account.Account, error) {
+func getAccountFromACP(program []byte, walletDB dbm.DB) (*account.Account, error) {
var hash common.Hash
accountCP := account.CtrlProgram{}
localAccount := account.Account{}
"sort"
log "github.com/sirupsen/logrus"
- "github.com/tendermint/tmlibs/db"
"github.com/bytom/account"
"github.com/bytom/asset"
chainjson "github.com/bytom/encoding/json"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
+ dbm "github.com/bytom/database/leveldb"
)
const (
}
// deleteTransaction delete transactions when orphan block rollback
-func (w *Wallet) deleteTransactions(batch db.Batch, height uint64) {
+func (w *Wallet) deleteTransactions(batch dbm.Batch, height uint64) {
tmpTx := query.AnnotatedTx{}
txIter := w.DB.IteratorPrefix(calcDeleteKey(height))
defer txIter.Release()
// saveExternalAssetDefinition save external and local assets definition,
// when query ,query local first and if have no then query external
// details see getAliasDefinition
-func saveExternalAssetDefinition(b *types.Block, walletDB db.DB) {
+func saveExternalAssetDefinition(b *types.Block, walletDB dbm.DB) {
storeBatch := walletDB.NewBatch()
defer storeBatch.Write()
}
// indexTransactions saves all annotated transactions to the database.
-func (w *Wallet) indexTransactions(batch db.Batch, b *types.Block, txStatus *bc.TransactionStatus) error {
+func (w *Wallet) indexTransactions(batch dbm.Batch, b *types.Block, txStatus *bc.TransactionStatus) error {
annotatedTxs := w.filterAccountTxs(b, txStatus)
saveExternalAssetDefinition(b, w.DB)
annotateTxsAccount(annotatedTxs, w.DB)
"sync/atomic"
"time"
- "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/blockchain/signers"
"github.com/bytom/crypto/ed25519/chainkd"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
+ dbm "github.com/bytom/database/leveldb"
)
const (
type recoveryManager struct {
mu sync.Mutex
- db db.DB
+ db dbm.DB
accountMgr *account.Manager
locked int32
}
// newRecoveryManager create recovery manger.
-func newRecoveryManager(db db.DB, accountMgr *account.Manager) *recoveryManager {
+func newRecoveryManager(db dbm.DB, accountMgr *account.Manager) *recoveryManager {
return &recoveryManager{
db: db,
accountMgr: accountMgr,
"testing"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/blockchain/signers"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
+ dbm "github.com/bytom/database/leveldb"
)
// MockBlock mock a block
"os"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/asset"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/event"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestWalletUnconfirmedTxs(t *testing.T) {
"encoding/json"
log "github.com/sirupsen/logrus"
- "github.com/tendermint/tmlibs/db"
"github.com/bytom/account"
"github.com/bytom/consensus"
"github.com/bytom/errors"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
+ dbm "github.com/bytom/database/leveldb"
)
// GetAccountUtxos return all account unspent outputs
return accountUtxos
}
-func (w *Wallet) attachUtxos(batch db.Batch, b *types.Block, txStatus *bc.TransactionStatus) {
+func (w *Wallet) attachUtxos(batch dbm.Batch, b *types.Block, txStatus *bc.TransactionStatus) {
for txIndex, tx := range b.Transactions {
statusFail, err := txStatus.GetStatus(txIndex)
if err != nil {
}
}
-func (w *Wallet) detachUtxos(batch db.Batch, b *types.Block, txStatus *bc.TransactionStatus) {
+func (w *Wallet) detachUtxos(batch dbm.Batch, b *types.Block, txStatus *bc.TransactionStatus) {
for txIndex := len(b.Transactions) - 1; txIndex >= 0; txIndex-- {
tx := b.Transactions[txIndex]
for j := range tx.Outputs {
return result
}
-func batchSaveUtxos(utxos []*account.UTXO, batch db.Batch) error {
+func batchSaveUtxos(utxos []*account.UTXO, batch dbm.Batch) error {
for _, utxo := range utxos {
data, err := json.Marshal(utxo)
if err != nil {
"sort"
"testing"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/consensus"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
"github.com/bytom/testutil"
+ dbm "github.com/bytom/database/leveldb"
)
func TestGetAccountUtxos(t *testing.T) {
"sync"
log "github.com/sirupsen/logrus"
- "github.com/tendermint/tmlibs/db"
"github.com/bytom/account"
"github.com/bytom/asset"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
+ dbm "github.com/bytom/database/leveldb"
)
const (
//Wallet is related to storing account unspent outputs
type Wallet struct {
- DB db.DB
+ DB dbm.DB
rw sync.RWMutex
status StatusInfo
AccountMgr *account.Manager
}
//NewWallet return a new wallet instance
-func NewWallet(walletDB db.DB, account *account.Manager, asset *asset.Registry, hsm *pseudohsm.HSM, chain *protocol.Chain, dispatcher *event.Dispatcher) (*Wallet, error) {
+func NewWallet(walletDB dbm.DB, account *account.Manager, asset *asset.Registry, hsm *pseudohsm.HSM, chain *protocol.Chain, dispatcher *event.Dispatcher) (*Wallet, error) {
w := &Wallet{
DB: walletDB,
AccountMgr: account,
return w.AttachBlock(block)
}
-func (w *Wallet) commitWalletInfo(batch db.Batch) error {
+func (w *Wallet) commitWalletInfo(batch dbm.Batch) error {
rawWallet, err := json.Marshal(w.status)
if err != nil {
log.WithFields(log.Fields{"module": logModule, "err": err}).Error("save wallet info")
"testing"
"time"
- dbm "github.com/tendermint/tmlibs/db"
-
"github.com/bytom/account"
"github.com/bytom/asset"
"github.com/bytom/blockchain/pseudohsm"
"github.com/bytom/config"
"github.com/bytom/consensus"
"github.com/bytom/crypto/ed25519/chainkd"
- "github.com/bytom/database/leveldb"
+ "github.com/bytom/database"
"github.com/bytom/event"
"github.com/bytom/protocol"
"github.com/bytom/protocol/bc"
"github.com/bytom/protocol/bc/types"
+ dbm "github.com/bytom/database/leveldb"
)
func TestWalletVersion(t *testing.T) {
testDB := dbm.NewDB("testdb", "leveldb", "temp")
defer os.RemoveAll("temp")
- store := leveldb.NewStore(testDB)
+ store := database.NewStore(testDB)
dispatcher := event.NewDispatcher()
txPool := protocol.NewTxPool(store, dispatcher)
testDB := dbm.NewDB("testdb", "leveldb", dirPath)
- store := leveldb.NewStore(testDB)
+ store := database.NewStore(testDB)
dispatcher := event.NewDispatcher()
txPool := protocol.NewTxPool(store, dispatcher)
OSDN Git Service
