path: root/core/db/memory.go

// 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 db

import (
    "encoding/json"
    "io/ioutil"
    "os"
    "sync"

    "github.com/dexon-foundation/dexon-consensus/common"
    "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg"
    "github.com/dexon-foundation/dexon-consensus/core/types"
)

type blockSeqIterator struct {
    idx int
    db  *MemBackedDB
}

// NextBlock implemenets BlockIterator.NextBlock method.
func (seq *blockSeqIterator) NextBlock() (types.Block, error) {
    curIdx := seq.idx
    seq.idx++
    return seq.db.getBlockByIndex(curIdx)
}

// MemBackedDB is a memory backed DB implementation.
type MemBackedDB struct {
    blocksLock               sync.RWMutex
    blockHashSequence        common.Hashes
    blocksByHash             map[common.Hash]*types.Block
    compactionChainTipLock   sync.RWMutex
    compactionChainTipHash   common.Hash
    compactionChainTipHeight uint64
    dkgPrivateKeysLock       sync.RWMutex
    dkgPrivateKeys           map[uint64]*dkg.PrivateKey
    dkgProtocolLock          sync.RWMutex
    dkgProtocolInfo          *DKGProtocolInfo
    persistantFilePath       string
}

// NewMemBackedDB initialize a memory-backed database.
func NewMemBackedDB(persistantFilePath ...string) (
    dbInst *MemBackedDB, err error) {
    dbInst = &MemBackedDB{
        blockHashSequence: common.Hashes{},
        blocksByHash:      make(map[common.Hash]*types.Block),
        dkgPrivateKeys:    make(map[uint64]*dkg.PrivateKey),
    }
    if len(persistantFilePath) == 0 || len(persistantFilePath[0]) == 0 {
        return
    }
    dbInst.persistantFilePath = persistantFilePath[0]
    buf, err := ioutil.ReadFile(dbInst.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
    }
    dbInst.blockHashSequence = toLoad.Sequence
    dbInst.blocksByHash = toLoad.ByHash
    return
}

// HasBlock returns wheter or not the DB has a block identified with the hash.
func (m *MemBackedDB) HasBlock(hash common.Hash) bool {
    m.blocksLock.RLock()
    defer m.blocksLock.RUnlock()

    _, ok := m.blocksByHash[hash]
    return ok
}

// GetBlock returns a block given a hash.
func (m *MemBackedDB) GetBlock(hash common.Hash) (types.Block, error) {
    m.blocksLock.RLock()
    defer m.blocksLock.RUnlock()

    return m.internalGetBlock(hash)
}

func (m *MemBackedDB) internalGetBlock(hash common.Hash) (types.Block, error) {
    b, ok := m.blocksByHash[hash]
    if !ok {
        return types.Block{}, ErrBlockDoesNotExist
    }
    return *b, nil
}

// PutBlock inserts a new block into the database.
func (m *MemBackedDB) PutBlock(block types.Block) error {
    if m.HasBlock(block.Hash) {
        return ErrBlockExists
    }

    m.blocksLock.Lock()
    defer m.blocksLock.Unlock()

    m.blockHashSequence = append(m.blockHashSequence, block.Hash)
    m.blocksByHash[block.Hash] = &block
    return nil
}

// UpdateBlock updates a block in the database.
func (m *MemBackedDB) UpdateBlock(block types.Block) error {
    if !m.HasBlock(block.Hash) {
        return ErrBlockDoesNotExist
    }

    m.blocksLock.Lock()
    defer m.blocksLock.Unlock()

    m.blocksByHash[block.Hash] = &block
    return nil
}

// PutCompactionChainTipInfo saves tip of compaction chain into the database.
func (m *MemBackedDB) PutCompactionChainTipInfo(
    blockHash common.Hash, height uint64) error {
    m.compactionChainTipLock.Lock()
    defer m.compactionChainTipLock.Unlock()
    if m.compactionChainTipHeight+1 != height {
        return ErrInvalidCompactionChainTipHeight
    }
    m.compactionChainTipHeight = height
    m.compactionChainTipHash = blockHash
    return nil
}

// GetCompactionChainTipInfo get the tip info of compaction chain into the
// database.
func (m *MemBackedDB) GetCompactionChainTipInfo() (
    hash common.Hash, height uint64) {
    m.compactionChainTipLock.RLock()
    defer m.compactionChainTipLock.RUnlock()
    return m.compactionChainTipHash, m.compactionChainTipHeight
}

// HasDKGPrivateKey check existence of DKG private key of one round.
func (m *MemBackedDB) HasDKGPrivateKey(round uint64) (bool, error) {
    m.dkgPrivateKeysLock.RLock()
    defer m.dkgPrivateKeysLock.RUnlock()
    _, exists := m.dkgPrivateKeys[round]
    return exists, nil
}

// GetDKGPrivateKey get DKG private key of one round.
func (m *MemBackedDB) GetDKGPrivateKey(round uint64) (
    dkg.PrivateKey, error) {
    m.dkgPrivateKeysLock.RLock()
    defer m.dkgPrivateKeysLock.RUnlock()
    if prv, exists := m.dkgPrivateKeys[round]; exists {
        return *prv, nil
    }
    return dkg.PrivateKey{}, ErrDKGPrivateKeyDoesNotExist
}

// PutDKGPrivateKey save DKG private key of one round.
func (m *MemBackedDB) PutDKGPrivateKey(
    round uint64, prv dkg.PrivateKey) error {
    m.dkgPrivateKeysLock.Lock()
    defer m.dkgPrivateKeysLock.Unlock()
    if _, exists := m.dkgPrivateKeys[round]; exists {
        return ErrDKGPrivateKeyExists
    }
    m.dkgPrivateKeys[round] = &prv
    return nil
}

// GetDKGProtocol get DKG protocol.
func (m *MemBackedDB) GetDKGProtocol() (
    DKGProtocolInfo, error) {
    m.dkgProtocolLock.RLock()
    defer m.dkgProtocolLock.RUnlock()
    if m.dkgProtocolInfo == nil {
        return DKGProtocolInfo{}, ErrDKGProtocolDoesNotExist
    }

    return *m.dkgProtocolInfo, nil
}

// PutOrUpdateDKGProtocol save DKG protocol.
func (m *MemBackedDB) PutOrUpdateDKGProtocol(dkgProtocol DKGProtocolInfo) error {
    m.dkgProtocolLock.Lock()
    defer m.dkgProtocolLock.Unlock()
    m.dkgProtocolInfo = &dkgProtocol
    return nil
}

// Close implement Closer interface, which would release allocated resource.
func (m *MemBackedDB) 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.blocksLock.RLock()
    defer m.blocksLock.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 *MemBackedDB) getBlockByIndex(idx int) (types.Block, error) {
    m.blocksLock.RLock()
    defer m.blocksLock.RUnlock()

    if idx >= len(m.blockHashSequence) {
        return types.Block{}, ErrIterationFinished
    }

    hash := m.blockHashSequence[idx]
    return m.internalGetBlock(hash)
}

// GetAllBlocks implement Reader.GetAllBlocks method, which allows caller
// to retrieve all blocks in DB.
func (m *MemBackedDB) GetAllBlocks() (BlockIterator, error) {
    return &blockSeqIterator{db: m}, nil
}