db: rename blockdb to db (#367)

* Rename blockdb package to db
* Rename 'BlockDB' to 'DB'
* Make all methods in db specific for ''block'.
* Rename db.BlockDatabase to db.Database
* Rename revealer to block-revealer
* Rename test.Revealer to test.BlockRevealer

5 files changed, 0 insertions, 646 deletions

diff --git a/core/blockdb/interfaces.go b/core/blockdb/interfaces.go
deleted file mode 100644
index c856307..0000000
--- a/core/blockdb/interfaces.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2018 The dexon-consensus Authors
-// This file is part of the dexon-consensus library.
-//
-// The dexon-consensus 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 dexon-consensus 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 dexon-consensus library. If not, see
-// <http://www.gnu.org/licenses/>.
-
-package blockdb
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/dexon-foundation/dexon-consensus/common"
-	"github.com/dexon-foundation/dexon-consensus/core/types"
-)
-
-var (
-	// ErrBlockExists is the error when block eixsts.
-	ErrBlockExists = errors.New("block exists")
-	// ErrBlockDoesNotExist is the error when block does not eixst.
-	ErrBlockDoesNotExist = errors.New("block does not exist")
-	// ErrIterationFinished is the error to check if the iteration is finished.
-	ErrIterationFinished = errors.New("iteration finished")
-	// ErrEmptyPath is the error when the required path is empty.
-	ErrEmptyPath = fmt.Errorf("empty path")
-	// ErrClosed is the error when using DB after it's closed.
-	ErrClosed = fmt.Errorf("db closed")
-	// ErrNotImplemented is the error that some interface is not implemented.
-	ErrNotImplemented = fmt.Errorf("not implemented")
-)
-
-// BlockDatabase is the interface for a BlockDatabase.
-type BlockDatabase interface {
-	Reader
-	Writer
-
-	// Close allows database implementation able to
-	// release resource when finishing.
-	Close() error
-}
-
-// Reader defines the interface for reading blocks into DB.
-type Reader interface {
-	Has(hash common.Hash) bool
-	Get(hash common.Hash) (types.Block, error)
-	GetAll() (BlockIterator, error)
-}
-
-// Writer defines the interface for writing blocks into DB.
-type Writer interface {
-	Update(block types.Block) error
-	Put(block types.Block) error
-}
-
-// BlockIterator defines an iterator on blocks hold
-// in a DB.
-type BlockIterator interface {
-	Next() (types.Block, error)
-}
diff --git a/core/blockdb/level-db.go b/core/blockdb/level-db.go
deleted file mode 100644
index 76730fc..0000000
--- a/core/blockdb/level-db.go
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2018 The dexon-consensus Authors
-// This file is part of the dexon-consensus library.
-//
-// The dexon-consensus 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 dexon-consensus 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 dexon-consensus library. If not, see
-// <http://www.gnu.org/licenses/>.
-
-package blockdb
-
-import (
-	"encoding/json"
-
-	"github.com/syndtr/goleveldb/leveldb"
-
-	"github.com/dexon-foundation/dexon-consensus/common"
-	"github.com/dexon-foundation/dexon-consensus/core/types"
-)
-
-// LevelDBBackedBlockDB is a leveldb backed BlockDB implementation.
-type LevelDBBackedBlockDB struct {
-	db *leveldb.DB
-}
-
-// NewLevelDBBackedBlockDB initialize a leveldb-backed block database.
-func NewLevelDBBackedBlockDB(
-	path string) (lvl *LevelDBBackedBlockDB, err error) {
-
-	db, err := leveldb.OpenFile(path, nil)
-	if err != nil {
-		return
-	}
-	lvl = &LevelDBBackedBlockDB{db: db}
-	return
-}
-
-// Close implement Closer interface, which would release allocated resource.
-func (lvl *LevelDBBackedBlockDB) Close() error {
-	return lvl.db.Close()
-}
-
-// Has implements the Reader.Has method.
-func (lvl *LevelDBBackedBlockDB) Has(hash common.Hash) bool {
-	exists, err := lvl.db.Has([]byte(hash[:]), nil)
-	if err != nil {
-		// TODO(missionliao): Modify the interface to return error.
-		panic(err)
-	}
-	return exists
-}
-
-// Get implements the Reader.Get method.
-func (lvl *LevelDBBackedBlockDB) Get(
-	hash common.Hash) (block types.Block, err error) {
-
-	queried, err := lvl.db.Get([]byte(hash[:]), nil)
-	if err != nil {
-		if err == leveldb.ErrNotFound {
-			err = ErrBlockDoesNotExist
-		}
-		return
-	}
-	err = json.Unmarshal(queried, &block)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Update implements the Writer.Update method.
-func (lvl *LevelDBBackedBlockDB) Update(block types.Block) (err error) {
-	// NOTE: we didn't handle changes of block hash (and it
-	//       should not happen).
-	marshaled, err := json.Marshal(&block)
-	if err != nil {
-		return
-	}
-
-	if !lvl.Has(block.Hash) {
-		err = ErrBlockDoesNotExist
-		return
-	}
-	err = lvl.db.Put(
-		[]byte(block.Hash[:]),
-		marshaled,
-		nil)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Put implements the Writer.Put method.
-func (lvl *LevelDBBackedBlockDB) Put(block types.Block) (err error) {
-	marshaled, err := json.Marshal(&block)
-	if err != nil {
-		return
-	}
-	if lvl.Has(block.Hash) {
-		err = ErrBlockExists
-		return
-	}
-	err = lvl.db.Put(
-		[]byte(block.Hash[:]),
-		marshaled,
-		nil)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// GetAll implements Reader.GetAll method, which allows callers
-// to retrieve all blocks in DB.
-func (lvl *LevelDBBackedBlockDB) GetAll() (BlockIterator, error) {
-	// TODO (mission): Implement this part via goleveldb's iterator.
-	return nil, ErrNotImplemented
-}
diff --git a/core/blockdb/level-db_test.go b/core/blockdb/level-db_test.go
deleted file mode 100644
index eb47b9c..0000000
--- a/core/blockdb/level-db_test.go
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2018 The dexon-consensus Authors
-// This file is part of the dexon-consensus library.
-//
-// The dexon-consensus 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 dexon-consensus 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 dexon-consensus library. If not, see
-// <http://www.gnu.org/licenses/>.
-
-package blockdb
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"os"
-
-	"github.com/stretchr/testify/suite"
-
-	"github.com/dexon-foundation/dexon-consensus/common"
-	"github.com/dexon-foundation/dexon-consensus/core/types"
-)
-
-type LevelDBTestSuite struct {
-	suite.Suite
-}
-
-func (s *LevelDBTestSuite) TestBasicUsage() {
-	dbName := fmt.Sprintf("test-db-%v.db", time.Now().UTC())
-	db, err := NewLevelDBBackedBlockDB(dbName)
-	s.Require().Nil(err)
-	defer func(dbName string) {
-		err = db.Close()
-		s.Nil(err)
-		err = os.RemoveAll(dbName)
-		s.Nil(err)
-	}(dbName)
-
-	// Queried something from an empty database.
-	hash1 := common.NewRandomHash()
-	_, err = db.Get(hash1)
-	s.Equal(ErrBlockDoesNotExist, err)
-
-	// Update on an empty database should not success.
-	node1 := types.NodeID{Hash: common.NewRandomHash()}
-	block1 := types.Block{
-		ProposerID: node1,
-		Hash:       hash1,
-		Position: types.Position{
-			Height: 1,
-		},
-	}
-	err = db.Update(block1)
-	s.Equal(ErrBlockDoesNotExist, err)
-
-	// Put to create a new record should just work fine.
-	err = db.Put(block1)
-	s.Nil(err)
-
-	// Get it back should work fine.
-	queried, err := db.Get(block1.Hash)
-	s.Nil(err)
-	s.Equal(queried.ProposerID, block1.ProposerID)
-
-	// Test Update.
-	now := time.Now().UTC()
-	queried.Timestamp = now
-
-	err = db.Update(queried)
-	s.Nil(err)
-
-	// Try to get it back via NodeID and height.
-	queried, err = db.Get(block1.Hash)
-
-	s.Nil(err)
-	s.Equal(now, queried.Timestamp)
-}
-
-func (s *LevelDBTestSuite) TestSyncIndex() {
-	dbName := fmt.Sprintf("test-db-%v-si.db", time.Now().UTC())
-	db, err := NewLevelDBBackedBlockDB(dbName)
-	s.Require().Nil(err)
-	defer func(dbName string) {
-		err = db.Close()
-		s.Nil(err)
-		err = os.RemoveAll(dbName)
-		s.Nil(err)
-	}(dbName)
-
-	// Create some blocks.
-	blocks := [10]types.Block{}
-	for i := range blocks {
-		block := types.Block{
-			ProposerID: types.NodeID{Hash: common.NewRandomHash()},
-			Hash:       common.NewRandomHash(),
-			Position: types.Position{
-				Height: uint64(i),
-			},
-		}
-		db.Put(block)
-		blocks[i] = block
-	}
-
-	// Save blocks to db.
-	err = db.Close()
-	s.Nil(err)
-
-	// Load back blocks(syncIndex is called).
-	db, err = NewLevelDBBackedBlockDB(dbName)
-	s.Require().Nil(err)
-
-	// Verify result.
-	for _, block := range blocks {
-		queried, err := db.Get(block.Hash)
-		s.Nil(err)
-		s.Equal(block.ProposerID, queried.ProposerID)
-		s.Equal(block.Position.Height, queried.Position.Height)
-	}
-}
-
-func TestLevelDB(t *testing.T) {
-	suite.Run(t, new(LevelDBTestSuite))
-}
diff --git a/core/blockdb/memory.go b/core/blockdb/memory.go
deleted file mode 100644
index b45af22..0000000
--- a/core/blockdb/memory.go
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright 2018 The dexon-consensus Authors
-// This file is part of the dexon-consensus library.
-//
-// The dexon-consensus 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 dexon-consensus 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 dexon-consensus library. If not, see
-// <http://www.gnu.org/licenses/>.
-
-package blockdb
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"os"
-	"sync"
-
-	"github.com/dexon-foundation/dexon-consensus/common"
-	"github.com/dexon-foundation/dexon-consensus/core/types"
-)
-
-type seqIterator struct {
-	idx int
-	db  *MemBackedBlockDB
-}
-
-func (seq *seqIterator) Next() (types.Block, error) {
-	curIdx := seq.idx
-	seq.idx++
-	return seq.db.getByIndex(curIdx)
-}
-
-// MemBackedBlockDB is a memory backed BlockDB implementation.
-type MemBackedBlockDB struct {
-	blocksMutex        sync.RWMutex
-	blockHashSequence  common.Hashes
-	blocksByHash       map[common.Hash]*types.Block
-	persistantFilePath string
-}
-
-// NewMemBackedBlockDB initialize a memory-backed block database.
-func NewMemBackedBlockDB(persistantFilePath ...string) (db *MemBackedBlockDB, err error) {
-	db = &MemBackedBlockDB{
-		blockHashSequence: common.Hashes{},
-		blocksByHash:      make(map[common.Hash]*types.Block),
-	}
-	if len(persistantFilePath) == 0 || len(persistantFilePath[0]) == 0 {
-		return
-	}
-	db.persistantFilePath = persistantFilePath[0]
-	buf, err := ioutil.ReadFile(db.persistantFilePath)
-	if err != nil {
-		if !os.IsNotExist(err) {
-			// Something unexpected happened.
-			return
-		}
-		// It's expected behavior that file doesn't exists, we should not
-		// report error on it.
-		err = nil
-		return
-	}
-
-	// Init this instance by file content, it's a temporary way
-	// to export those private field for JSON encoding.
-	toLoad := struct {
-		Sequence common.Hashes
-		ByHash   map[common.Hash]*types.Block
-	}{}
-	err = json.Unmarshal(buf, &toLoad)
-	if err != nil {
-		return
-	}
-	db.blockHashSequence = toLoad.Sequence
-	db.blocksByHash = toLoad.ByHash
-	return
-}
-
-// Has returns wheter or not the DB has a block identified with the hash.
-func (m *MemBackedBlockDB) Has(hash common.Hash) bool {
-	m.blocksMutex.RLock()
-	defer m.blocksMutex.RUnlock()
-
-	_, ok := m.blocksByHash[hash]
-	return ok
-}
-
-// Get returns a block given a hash.
-func (m *MemBackedBlockDB) Get(hash common.Hash) (types.Block, error) {
-	m.blocksMutex.RLock()
-	defer m.blocksMutex.RUnlock()
-
-	return m.internalGet(hash)
-}
-
-func (m *MemBackedBlockDB) internalGet(hash common.Hash) (types.Block, error) {
-	b, ok := m.blocksByHash[hash]
-	if !ok {
-		return types.Block{}, ErrBlockDoesNotExist
-	}
-	return *b, nil
-}
-
-// Put inserts a new block into the database.
-func (m *MemBackedBlockDB) Put(block types.Block) error {
-	if m.Has(block.Hash) {
-		return ErrBlockExists
-	}
-
-	m.blocksMutex.Lock()
-	defer m.blocksMutex.Unlock()
-
-	m.blockHashSequence = append(m.blockHashSequence, block.Hash)
-	m.blocksByHash[block.Hash] = &block
-	return nil
-}
-
-// Update updates a block in the database.
-func (m *MemBackedBlockDB) Update(block types.Block) error {
-	if !m.Has(block.Hash) {
-		return ErrBlockDoesNotExist
-	}
-
-	m.blocksMutex.Lock()
-	defer m.blocksMutex.Unlock()
-
-	m.blocksByHash[block.Hash] = &block
-	return nil
-}
-
-// Close implement Closer interface, which would release allocated resource.
-func (m *MemBackedBlockDB) Close() (err error) {
-	// Save internal state to a pretty-print json file. It's a temporary way
-	// to dump private file via JSON encoding.
-	if len(m.persistantFilePath) == 0 {
-		return
-	}
-
-	m.blocksMutex.RLock()
-	defer m.blocksMutex.RUnlock()
-
-	toDump := struct {
-		Sequence common.Hashes
-		ByHash   map[common.Hash]*types.Block
-	}{
-		Sequence: m.blockHashSequence,
-		ByHash:   m.blocksByHash,
-	}
-
-	// Dump to JSON with 2-space indent.
-	buf, err := json.Marshal(&toDump)
-	if err != nil {
-		return
-	}
-
-	err = ioutil.WriteFile(m.persistantFilePath, buf, 0644)
-	return
-}
-
-func (m *MemBackedBlockDB) getByIndex(idx int) (types.Block, error) {
-	m.blocksMutex.RLock()
-	defer m.blocksMutex.RUnlock()
-
-	if idx >= len(m.blockHashSequence) {
-		return types.Block{}, ErrIterationFinished
-	}
-
-	hash := m.blockHashSequence[idx]
-	return m.internalGet(hash)
-}
-
-// GetAll implement Reader.GetAll method, which allows caller
-// to retrieve all blocks in DB.
-func (m *MemBackedBlockDB) GetAll() (BlockIterator, error) {
-	return &seqIterator{db: m}, nil
-}
diff --git a/core/blockdb/memory_test.go b/core/blockdb/memory_test.go
deleted file mode 100644
index e0c0aad..0000000
--- a/core/blockdb/memory_test.go
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2018 The dexon-consensus Authors
-// This file is part of the dexon-consensus library.
-//
-// The dexon-consensus 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 dexon-consensus 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 dexon-consensus library. If not, see
-// <http://www.gnu.org/licenses/>.
-
-package blockdb
-
-import (
-	"os"
-	"testing"
-
-	"github.com/dexon-foundation/dexon-consensus/common"
-	"github.com/dexon-foundation/dexon-consensus/core/types"
-	"github.com/stretchr/testify/suite"
-)
-
-type MemBackedBlockDBTestSuite struct {
-	suite.Suite
-
-	v0            types.NodeID
-	b00, b01, b02 *types.Block
-}
-
-func (s *MemBackedBlockDBTestSuite) SetupSuite() {
-	s.v0 = types.NodeID{Hash: common.NewRandomHash()}
-
-	genesisHash := common.NewRandomHash()
-	s.b00 = &types.Block{
-		ProposerID: s.v0,
-		ParentHash: genesisHash,
-		Hash:       genesisHash,
-		Position: types.Position{
-			Height: 0,
-		},
-		Acks: common.NewSortedHashes(common.Hashes{}),
-	}
-	s.b01 = &types.Block{
-		ProposerID: s.v0,
-		ParentHash: s.b00.Hash,
-		Hash:       common.NewRandomHash(),
-		Position: types.Position{
-			Height: 1,
-		},
-		Acks: common.NewSortedHashes(common.Hashes{s.b00.Hash}),
-	}
-	s.b02 = &types.Block{
-		ProposerID: s.v0,
-		ParentHash: s.b01.Hash,
-		Hash:       common.NewRandomHash(),
-		Position: types.Position{
-			Height: 2,
-		},
-		Acks: common.NewSortedHashes(common.Hashes{s.b01.Hash}),
-	}
-}
-
-func (s *MemBackedBlockDBTestSuite) TestSaveAndLoad() {
-	// Make sure we are able to save/load from file.
-	dbPath := "test-save-and-load.db"
-
-	// Make sure the file pointed by 'dbPath' doesn't exist.
-	_, err := os.Stat(dbPath)
-	s.Require().NotNil(err)
-
-	db, err := NewMemBackedBlockDB(dbPath)
-	s.Require().Nil(err)
-	s.Require().NotNil(db)
-	defer func() {
-		if db != nil {
-			s.Nil(os.Remove(dbPath))
-			db = nil
-		}
-	}()
-
-	s.Nil(db.Put(*s.b00))
-	s.Nil(db.Put(*s.b01))
-	s.Nil(db.Put(*s.b02))
-	s.Nil(db.Close())
-
-	// Load the json file back to check if all inserted blocks
-	// exists.
-	db, err = NewMemBackedBlockDB(dbPath)
-	s.Require().Nil(err)
-	s.Require().NotNil(db)
-	s.True(db.Has(s.b00.Hash))
-	s.True(db.Has(s.b01.Hash))
-	s.True(db.Has(s.b02.Hash))
-	s.Nil(db.Close())
-}
-
-func (s *MemBackedBlockDBTestSuite) TestIteration() {
-	// Make sure the file pointed by 'dbPath' doesn't exist.
-	db, err := NewMemBackedBlockDB()
-	s.Require().Nil(err)
-	s.Require().NotNil(db)
-
-	// Setup database.
-	s.Nil(db.Put(*s.b00))
-	s.Nil(db.Put(*s.b01))
-	s.Nil(db.Put(*s.b02))
-
-	// Check if we can iterate all 3 blocks.
-	iter, err := db.GetAll()
-	s.Require().Nil(err)
-	touched := common.Hashes{}
-	for {
-		b, err := iter.Next()
-		if err == ErrIterationFinished {
-			break
-		}
-		s.Require().Nil(err)
-		touched = append(touched, b.Hash)
-	}
-	s.Len(touched, 3)
-	s.Contains(touched, s.b00.Hash)
-	s.Contains(touched, s.b01.Hash)
-	s.Contains(touched, s.b02.Hash)
-}
-
-func TestMemBackedBlockDB(t *testing.T) {
-	suite.Run(t, new(MemBackedBlockDBTestSuite))
-}