path: root/blockdb/memory.go

// Copyright 2018 The dexon-consensus-core Authors
// This file is part of the dexon-consensus-core library.
//
// The dexon-consensus-core 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-core 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-core library. If not, see
// <http://www.gnu.org/licenses/>.

package blockdb

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

    "github.com/dexon-foundation/dexon-consensus-core/common"
    "github.com/dexon-foundation/dexon-consensus-core/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 {
    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
}