From b0e0dc5de387ccdf96cb4c3e0637f07c73e5e9e0 Mon Sep 17 00:00:00 2001 From: Jae Kwon Date: Sun, 18 Mar 2018 01:52:28 +0100 Subject: [PATCH] Implement DebugDB (#166) --- db/common_test.go | 6 +- db/db_test.go | 12 ++- db/debug_db.go | 216 ++++++++++++++++++++++++++++++++++++++++++ db/mem_batch.go | 7 +- db/prefix_db.go | 10 +- merkle/simple_tree.go | 3 + 6 files changed, 239 insertions(+), 15 deletions(-) create mode 100644 db/debug_db.go diff --git a/db/common_test.go b/db/common_test.go index 5afec28b3..7f9d10e9b 100644 --- a/db/common_test.go +++ b/db/common_test.go @@ -107,11 +107,11 @@ func (mdb *mockDB) SetNoLockSync([]byte, []byte) { mdb.calls["SetNoLockSync"] += 1 } -func (mdb *mockDB) Delete([]byte, []byte) { +func (mdb *mockDB) Delete([]byte) { mdb.calls["Delete"] += 1 } -func (mdb *mockDB) DeleteSync([]byte, []byte) { +func (mdb *mockDB) DeleteSync([]byte) { mdb.calls["DeleteSync"] += 1 } @@ -144,7 +144,7 @@ func (mdb *mockDB) NewBatch() Batch { func (mdb *mockDB) Print() { mdb.calls["Print"] += 1 - fmt.Sprintf("mockDB{%v}", mdb.Stats()) + fmt.Printf("mockDB{%v}", mdb.Stats()) } func (mdb *mockDB) Stats() map[string]string { diff --git a/db/db_test.go b/db/db_test.go index 8884cea2d..3d6ac38c4 100644 --- a/db/db_test.go +++ b/db/db_test.go @@ -111,7 +111,8 @@ func TestDBIteratorNonemptyBeginAfter(t *testing.T) { func TestDBBatchWrite1(t *testing.T) { mdb := newMockDB() - batch := mdb.NewBatch() + ddb := NewDebugDB(t.Name(), mdb) + batch := ddb.NewBatch() batch.Set(bz("1"), bz("1")) batch.Set(bz("2"), bz("2")) @@ -131,7 +132,8 @@ func TestDBBatchWrite1(t *testing.T) { func TestDBBatchWrite2(t *testing.T) { mdb := newMockDB() - batch := mdb.NewBatch() + ddb := NewDebugDB(t.Name(), mdb) + batch := ddb.NewBatch() batch.Set(bz("1"), bz("1")) batch.Set(bz("2"), bz("2")) @@ -151,7 +153,8 @@ func TestDBBatchWrite2(t *testing.T) { func TestDBBatchWriteSync1(t *testing.T) { mdb := newMockDB() - batch := mdb.NewBatch() + ddb := NewDebugDB(t.Name(), mdb) + batch := ddb.NewBatch() batch.Set(bz("1"), bz("1")) batch.Set(bz("2"), bz("2")) @@ -171,7 +174,8 @@ func TestDBBatchWriteSync1(t *testing.T) { func TestDBBatchWriteSync2(t *testing.T) { mdb := newMockDB() - batch := mdb.NewBatch() + ddb := NewDebugDB(t.Name(), mdb) + batch := ddb.NewBatch() batch.Set(bz("1"), bz("1")) batch.Set(bz("2"), bz("2")) diff --git a/db/debug_db.go b/db/debug_db.go new file mode 100644 index 000000000..7a15bc294 --- /dev/null +++ b/db/debug_db.go @@ -0,0 +1,216 @@ +package db + +import ( + "fmt" + "sync" +) + +//---------------------------------------- +// debugDB + +type debugDB struct { + label string + db DB +} + +// For printing all operationgs to the console for debugging. +func NewDebugDB(label string, db DB) debugDB { + return debugDB{ + label: label, + db: db, + } +} + +// Implements atomicSetDeleter. +func (ddb debugDB) Mutex() *sync.Mutex { return nil } + +// Implements DB. +func (ddb debugDB) Get(key []byte) (value []byte) { + defer fmt.Printf("%v.Get(%X) %X\n", ddb.label, key, value) + value = ddb.db.Get(key) + return +} + +// Implements DB. +func (ddb debugDB) Has(key []byte) (has bool) { + defer fmt.Printf("%v.Has(%X) %v\n", ddb.label, key, has) + return ddb.db.Has(key) +} + +// Implements DB. +func (ddb debugDB) Set(key []byte, value []byte) { + fmt.Printf("%v.Set(%X, %X)\n", ddb.label, key, value) + ddb.db.Set(key, value) +} + +// Implements DB. +func (ddb debugDB) SetSync(key []byte, value []byte) { + fmt.Printf("%v.SetSync(%X, %X)\n", ddb.label, key, value) + ddb.db.SetSync(key, value) +} + +// Implements atomicSetDeleter. +func (ddb debugDB) SetNoLock(key []byte, value []byte) { + fmt.Printf("%v.SetNoLock(%X, %X)\n", ddb.label, key, value) + ddb.db.Set(key, value) +} + +// Implements atomicSetDeleter. +func (ddb debugDB) SetNoLockSync(key []byte, value []byte) { + fmt.Printf("%v.SetNoLockSync(%X, %X)\n", ddb.label, key, value) + ddb.db.SetSync(key, value) +} + +// Implements DB. +func (ddb debugDB) Delete(key []byte) { + fmt.Printf("%v.Delete(%X)\n", ddb.label, key) + ddb.db.Delete(key) +} + +// Implements DB. +func (ddb debugDB) DeleteSync(key []byte) { + fmt.Printf("%v.DeleteSync(%X)\n", ddb.label, key) + ddb.db.DeleteSync(key) +} + +// Implements atomicSetDeleter. +func (ddb debugDB) DeleteNoLock(key []byte) { + fmt.Printf("%v.DeleteNoLock(%X)\n", ddb.label, key) + ddb.db.Delete(key) +} + +// Implements atomicSetDeleter. +func (ddb debugDB) DeleteNoLockSync(key []byte) { + fmt.Printf("%v.DeleteNoLockSync(%X)\n", ddb.label, key) + ddb.db.DeleteSync(key) +} + +// Implements DB. +func (ddb debugDB) Iterator(start, end []byte) Iterator { + fmt.Printf("%v.Iterator(%X, %X)\n", ddb.label, start, end) + return NewDebugIterator(ddb.label, ddb.db.Iterator(start, end)) +} + +// Implements DB. +func (ddb debugDB) ReverseIterator(start, end []byte) Iterator { + fmt.Printf("%v.ReverseIterator(%X, %X)\n", ddb.label, start, end) + return NewDebugIterator(ddb.label, ddb.db.ReverseIterator(start, end)) +} + +// Implements DB. +func (ddb debugDB) NewBatch() Batch { + fmt.Printf("%v.NewBatch()\n", ddb.label) + return NewDebugBatch(ddb.label, ddb.db.NewBatch()) +} + +// Implements DB. +func (ddb debugDB) Close() { + fmt.Printf("%v.Close()\n", ddb.label) + ddb.db.Close() +} + +// Implements DB. +func (ddb debugDB) Print() { + ddb.db.Print() +} + +// Implements DB. +func (ddb debugDB) Stats() map[string]string { + return ddb.db.Stats() +} + +//---------------------------------------- +// debugIterator + +type debugIterator struct { + label string + itr Iterator +} + +// For printing all operationgs to the console for debugging. +func NewDebugIterator(label string, itr Iterator) debugIterator { + return debugIterator{ + label: label, + itr: itr, + } +} + +// Implements Iterator. +func (ditr debugIterator) Domain() (start []byte, end []byte) { + defer fmt.Printf("%v.itr.Domain() (%X,%X)\n", ditr.label, start, end) + start, end = ditr.itr.Domain() + return +} + +// Implements Iterator. +func (ditr debugIterator) Valid() (ok bool) { + defer fmt.Printf("%v.itr.Valid() %v\n", ditr.label, ok) + ok = ditr.itr.Valid() + return +} + +// Implements Iterator. +func (ditr debugIterator) Next() { + fmt.Printf("%v.itr.Next()\n", ditr.label) + ditr.itr.Next() +} + +// Implements Iterator. +func (ditr debugIterator) Key() (key []byte) { + fmt.Printf("%v.itr.Key() %X\n", ditr.label, key) + key = ditr.itr.Key() + return +} + +// Implements Iterator. +func (ditr debugIterator) Value() (value []byte) { + fmt.Printf("%v.itr.Value() %X\n", ditr.label, value) + value = ditr.itr.Value() + return +} + +// Implements Iterator. +func (ditr debugIterator) Close() { + fmt.Printf("%v.itr.Close()\n", ditr.label) + ditr.itr.Close() +} + +//---------------------------------------- +// debugBatch + +type debugBatch struct { + label string + bch Batch +} + +// For printing all operationgs to the console for debugging. +func NewDebugBatch(label string, bch Batch) debugBatch { + return debugBatch{ + label: label, + bch: bch, + } +} + +// Implements Batch. +func (dbch debugBatch) Set(key, value []byte) { + fmt.Printf("%v.batch.Set(%X, %X)\n", dbch.label, key, value) + dbch.bch.Set(key, value) +} + +// Implements Batch. +func (dbch debugBatch) Delete(key []byte) { + fmt.Printf("%v.batch.Delete(%X)\n", dbch.label, key) + dbch.bch.Delete(key) +} + +// Implements Batch. +func (dbch debugBatch) Write() { + fmt.Printf("%v.batch.Write()\n", dbch.label) + dbch.bch.Write() +} + +// Implements Batch. +func (dbch debugBatch) WriteSync() { + fmt.Printf("%v.batch.WriteSync()\n", dbch.label) + dbch.bch.WriteSync() +} diff --git a/db/mem_batch.go b/db/mem_batch.go index 756798ded..81a63d62b 100644 --- a/db/mem_batch.go +++ b/db/mem_batch.go @@ -45,9 +45,10 @@ func (mBatch *memBatch) WriteSync() { } func (mBatch *memBatch) write(doSync bool) { - mtx := mBatch.db.Mutex() - mtx.Lock() - defer mtx.Unlock() + if mtx := mBatch.db.Mutex(); mtx != nil { + mtx.Lock() + defer mtx.Unlock() + } for i, op := range mBatch.ops { if doSync && i == (len(mBatch.ops)-1) { diff --git a/db/prefix_db.go b/db/prefix_db.go index 5947e7fce..4381ce070 100644 --- a/db/prefix_db.go +++ b/db/prefix_db.go @@ -123,10 +123,10 @@ func (pdb *prefixDB) Iterator(start, end []byte) Iterator { pdb.mtx.Lock() defer pdb.mtx.Unlock() - pstart := append([]byte(pdb.prefix), start...) + pstart := append(pdb.prefix, start...) pend := []byte(nil) if end != nil { - pend = append([]byte(pdb.prefix), end...) + pend = append(pdb.prefix, end...) } return newUnprefixIterator( pdb.prefix, @@ -144,11 +144,11 @@ func (pdb *prefixDB) ReverseIterator(start, end []byte) Iterator { pstart := []byte(nil) if start != nil { - pstart = append([]byte(pdb.prefix), start...) + pstart = append(pdb.prefix, start...) } pend := []byte(nil) if end != nil { - pend = append([]byte(pdb.prefix), end...) + pend = append(pdb.prefix, end...) } return newUnprefixIterator( pdb.prefix, @@ -201,7 +201,7 @@ func (pdb *prefixDB) Stats() map[string]string { } func (pdb *prefixDB) prefixed(key []byte) []byte { - return append([]byte(pdb.prefix), key...) + return append(pdb.prefix, key...) } //---------------------------------------- diff --git a/merkle/simple_tree.go b/merkle/simple_tree.go index a363ea8e8..9bdf52cb2 100644 --- a/merkle/simple_tree.go +++ b/merkle/simple_tree.go @@ -31,6 +31,9 @@ import ( func SimpleHashFromTwoHashes(left []byte, right []byte) []byte { var hasher = ripemd160.New() err := encodeByteSlice(hasher, left) + if err != nil { + panic(err) + } err = encodeByteSlice(hasher, right) if err != nil { panic(err)