path: root/core/agreement-state.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 core

import (
    "fmt"
    "sync"

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

// Errors for agreement state module.
var (
    ErrNoEnoughVoteInPrepareState = fmt.Errorf("no enough vote in prepare state")
    ErrNoEnoughVoteInAckState     = fmt.Errorf("no enough vote in ack state")
)

// agreementStateType is the state of agreement
type agreementStateType int

// agreementStateType enum.
const (
    statePrepare agreementStateType = iota
    stateAck
    stateConfirm
    statePass1
    statePass2
)

var nullBlockHash = common.Hash{}

type agreementState interface {
    state() agreementStateType
    nextState() (agreementState, error)
    receiveVote() error
    clocks() int
    terminate()
}

//----- PrepareState -----
type prepareState struct {
    a *agreementData
}

func newPrepareState(a *agreementData) *prepareState {
    return &prepareState{a: a}
}

func (s *prepareState) state() agreementStateType { return statePrepare }
func (s *prepareState) clocks() int               { return 0 }
func (s *prepareState) terminate()                {}
func (s *prepareState) nextState() (agreementState, error) {
    hash := common.Hash{}
    if s.a.period == 1 {
        hash = s.a.blockProposer().Hash
        s.a.recv.ProposeBlock(hash)
    } else {
        var proposed bool
        _, proposed = s.a.countVote(s.a.period-1, types.VotePass)
        if !proposed {
            return nil, ErrNoEnoughVoteInPrepareState
        }
    }
    return newAckState(s.a), nil
}
func (s *prepareState) receiveVote() error { return nil }

// ----- AckState -----
type ackState struct {
    a *agreementData
}

func newAckState(a *agreementData) *ackState {
    return &ackState{a: a}
}

func (s *ackState) state() agreementStateType { return stateAck }
func (s *ackState) clocks() int               { return 2 }
func (s *ackState) terminate()                {}
func (s *ackState) nextState() (agreementState, error) {
    acked := false
    hash := common.Hash{}
    if s.a.period == 1 {
        acked = true
    } else {
        hash, acked = s.a.countVote(s.a.period-1, types.VotePass)
    }
    if !acked {
        return nil, ErrNoEnoughVoteInAckState
    }
    if hash == nullBlockHash {
        hash = s.a.leader.leaderBlockHash()
    }
    s.a.recv.ProposeVote(&types.Vote{
        Type:      types.VoteAck,
        BlockHash: hash,
        Period:    s.a.period,
    })
    return newConfirmState(s.a), nil
}
func (s *ackState) receiveVote() error { return nil }

// ----- ConfirmState -----
type confirmState struct {
    a     *agreementData
    lock  sync.Mutex
    voted bool
}

func newConfirmState(a *agreementData) *confirmState {
    return &confirmState{
        a: a,
    }
}

func (s *confirmState) state() agreementStateType { return stateConfirm }
func (s *confirmState) clocks() int               { return 2 }
func (s *confirmState) terminate()                {}
func (s *confirmState) nextState() (agreementState, error) {
    return newPass1State(s.a), nil
}
func (s *confirmState) receiveVote() error {
    s.lock.Lock()
    defer s.lock.Unlock()
    if s.voted {
        return nil
    }
    hash, ok := s.a.countVote(s.a.period, types.VoteAck)
    if !ok {
        return nil
    }
    if hash != nullBlockHash {
        s.a.recv.ProposeVote(&types.Vote{
            Type:      types.VoteConfirm,
            BlockHash: hash,
            Period:    s.a.period,
        })
        s.voted = true
    }
    return nil
}

// ----- Pass1State -----
type pass1State struct {
    a *agreementData
}

func newPass1State(a *agreementData) *pass1State {
    return &pass1State{a: a}
}

func (s *pass1State) state() agreementStateType { return statePass1 }
func (s *pass1State) clocks() int               { return 0 }
func (s *pass1State) terminate()                {}
func (s *pass1State) nextState() (agreementState, error) {
    voteDefault := false
    if vote, exist := func() (*types.Vote, bool) {
        s.a.votesLock.RLock()
        defer s.a.votesLock.RUnlock()
        v, e := s.a.votes[s.a.period][types.VoteConfirm][s.a.ID]
        return v, e
    }(); exist {
        s.a.recv.ProposeVote(&types.Vote{
            Type:      types.VotePass,
            BlockHash: vote.BlockHash,
            Period:    s.a.period,
        })
    } else if s.a.period == 1 {
        voteDefault = true
    } else {
        hash, ok := s.a.countVote(s.a.period-1, types.VotePass)
        if ok {
            if hash == nullBlockHash {
                s.a.recv.ProposeVote(&types.Vote{
                    Type:      types.VotePass,
                    BlockHash: hash,
                    Period:    s.a.period,
                })
            } else {
                voteDefault = true
            }
        } else {
            voteDefault = true
        }
    }
    if voteDefault {
        s.a.recv.ProposeVote(&types.Vote{
            Type:      types.VotePass,
            BlockHash: s.a.defaultBlock,
            Period:    s.a.period,
        })
    }
    return newPass2State(s.a), nil
}
func (s *pass1State) receiveVote() error { return nil }

// ----- Pass2State -----
type pass2State struct {
    a              *agreementData
    lock           sync.Mutex
    voted          bool
    enoughPassVote chan common.Hash
    terminateChan  chan struct{}
}

func newPass2State(a *agreementData) *pass2State {
    return &pass2State{
        a:              a,
        enoughPassVote: make(chan common.Hash, 1),
        terminateChan:  make(chan struct{}),
    }
}

func (s *pass2State) state() agreementStateType { return statePass2 }
func (s *pass2State) clocks() int               { return 0 }
func (s *pass2State) terminate() {
    s.terminateChan <- struct{}{}
}
func (s *pass2State) nextState() (agreementState, error) {
    select {
    case <-s.terminateChan:
        break
    case hash := <-s.enoughPassVote:
        s.a.votesLock.RLock()
        defer s.a.votesLock.RUnlock()
        s.a.defaultBlock = hash
        s.a.period++
        oldBlock := s.a.blocks[s.a.ID]
        s.a.blocks = map[types.NodeID]*types.Block{
            s.a.ID: oldBlock,
        }
    }
    return newPrepareState(s.a), nil
}
func (s *pass2State) receiveVote() error {
    s.lock.Lock()
    defer s.lock.Unlock()
    if s.voted {
        return nil
    }
    hash, ok := s.a.countVote(s.a.period, types.VotePass)
    if ok {
        s.voted = true
        s.enoughPassVote <- hash
    }
    return nil
}