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