path: root/simulation/validator.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 simulation

import (
    "fmt"
    "time"

    "github.com/dexon-foundation/dexon-consensus-core/blockdb"
    "github.com/dexon-foundation/dexon-consensus-core/common"
    "github.com/dexon-foundation/dexon-consensus-core/core"
    "github.com/dexon-foundation/dexon-consensus-core/core/types"
    "github.com/dexon-foundation/dexon-consensus-core/crypto"
    "github.com/dexon-foundation/dexon-consensus-core/simulation/config"
)

// Validator represents a validator in DexCon.
type Validator struct {
    network Network
    app     *simApp
    gov     *simGovernance
    db      blockdb.BlockDatabase

    config     config.Validator
    msgChannel chan interface{}
    isFinished chan struct{}

    ID              types.ValidatorID
    privateKey      crypto.PrivateKey
    consensus       *core.Consensus
    compactionChain *core.BlockChain
}

// NewValidator returns a new empty validator.
func NewValidator(
    prvKey crypto.PrivateKey,
    config config.Validator,
    network Network) *Validator {

    id := types.NewValidatorID(prvKey.PublicKey())

    db, err := blockdb.NewMemBackedBlockDB(
        id.String() + ".blockdb")
    if err != nil {
        panic(err)
    }
    gov := newSimGovernance(config.Num, config.Consensus)
    gov.addValidator(id)
    return &Validator{
        ID:         id,
        config:     config,
        network:    network,
        app:        newSimApp(id, network),
        gov:        gov,
        db:         db,
        isFinished: make(chan struct{}),
    }
}

// GetID returns the ID of validator.
func (v *Validator) GetID() types.ValidatorID {
    return v.ID
}

// Run starts the validator.
func (v *Validator) Run() {
    v.msgChannel = v.network.Join(v)

    genesisBlock := &types.Block{
        ProposerID: v.ID,
        ParentHash: common.Hash{},
        Hash:       common.NewRandomHash(),
        Height:     0,
        Acks:       map[common.Hash]struct{}{},
        Timestamps: map[types.ValidatorID]time.Time{
            v.ID: time.Now().UTC(),
        },
    }
    isStopped := make(chan struct{}, 2)
    isShutdown := make(chan struct{})

    v.app.addBlock(genesisBlock)
    v.BroadcastGenesisBlock(genesisBlock)
    go v.MsgServer(isStopped, genesisBlock)
    go v.CheckServerInfo(isShutdown)
    go v.BlockProposer(isStopped, isShutdown)

    // Blocks forever.
    <-isStopped
    if err := v.db.Close(); err != nil {
        fmt.Println(err)
    }
    v.network.NotifyServer(Message{
        Type: shutdownAck,
    })
    v.isFinished <- struct{}{}
}

// Wait for the validator to stop (if peerServer told it to).
func (v *Validator) Wait() {
    <-v.isFinished
}

// CheckServerInfo will check the info from the peerServer and update
// validator's status if needed.
func (v *Validator) CheckServerInfo(isShutdown chan struct{}) {
    for {
        infoMsg := v.network.GetServerInfo()
        if infoMsg.Status == statusShutdown {
            isShutdown <- struct{}{}
            break
        }
        time.Sleep(250 * time.Millisecond)
    }
}

// MsgServer listen to the network channel for message and handle it.
func (v *Validator) MsgServer(
    isStopped chan struct{}, genesisBlock *types.Block) {

    pendingBlocks := []*types.Block{genesisBlock}
    for {
        var msg interface{}
        select {
        case msg = <-v.msgChannel:
        case <-isStopped:
            return
        }

        switch val := msg.(type) {
        case *types.Block:
            v.app.addBlock(val)
            if v.consensus != nil {
                if err := v.consensus.ProcessBlock(val); err != nil {
                    fmt.Println(err)
                    //panic(err)
                }
            } else {
                pendingBlocks = append(pendingBlocks, val)
                if val.IsGenesis() {
                    v.gov.addValidator(val.ProposerID)
                }
                validatorSet := v.gov.GetValidatorSet()
                if len(validatorSet) != v.config.Num {
                    // We don't collect all validators yet.
                    break
                }
                v.consensus = core.NewConsensus(v.app, v.gov, v.db)
                for _, b := range pendingBlocks {
                    if err := v.consensus.ProcessBlock(b); err != nil {
                        fmt.Println(err)
                        //panic(err)
                    }
                }
                pendingBlocks = pendingBlocks[:0]
            }
        }
    }
}

// BroadcastGenesisBlock broadcasts genesis block to all peers.
func (v *Validator) BroadcastGenesisBlock(genesisBlock *types.Block) {
    // Wait until all peer joined the network.
    for v.network.NumPeers() != v.config.Num {
        time.Sleep(time.Second)
    }
    v.network.BroadcastBlock(genesisBlock)
}

// BlockProposer propose blocks to be send to the DEXON network.
func (v *Validator) BlockProposer(isStopped, isShutdown chan struct{}) {
    // Wait until all genesis blocks are received.
    for v.consensus == nil {
        time.Sleep(time.Second)
    }
    model := &NormalNetwork{
        Sigma: v.config.ProposeIntervalSigma,
        Mean:  v.config.ProposeIntervalMean,
    }
ProposingBlockLoop:
    for {
        time.Sleep(model.Delay())

        block := &types.Block{
            ProposerID: v.ID,
            Hash:       common.NewRandomHash(),
        }
        if err := v.consensus.PrepareBlock(block, time.Now().UTC()); err != nil {
            panic(err)
        }
        v.app.addBlock(block)
        if err := v.consensus.ProcessBlock(block); err != nil {
            fmt.Println(err)
            //panic(err)
        }
        v.network.BroadcastBlock(block)
        select {
        case <-isShutdown:
            isStopped <- struct{}{}
            isStopped <- struct{}{}
            break ProposingBlockLoop
        default:
            break
        }
    }
}