Merge pull request #73 from getamis/feature/rename-pbft-to-istanbul

All hail Istanbul

Author: alanchchen

cmd/geth/main.go

@@ -103,11 +103,11 @@ var (
 		utils.GpoPercentileFlag,
 		utils.ExtraDataFlag,
 		configFileFlag,
-		utils.PBFTRequestTimeoutFlag,
-		utils.PBFTBlockPeriodFlag,
-		utils.PBFTBlockPauseTimeFlag,
-		utils.PBFTProposerPolicyFlag,
-		utils.PBFTCheckPointPeriodFlag,
+		utils.IstanbulRequestTimeoutFlag,
+		utils.IstanbulBlockPeriodFlag,
+		utils.IstanbulBlockPauseTimeFlag,
+		utils.IstanbulProposerPolicyFlag,
+		utils.IstanbulCheckPointPeriodFlag,
 	}
 
 	rpcFlags = []cli.Flag{

cmd/geth/usage.go

@@ -188,13 +188,13 @@ var AppHelpFlagGroups = []flagGroup{
 		},
 	},
 	{
-		Name: "PBFT",
+		Name: "Istanbul",
 		Flags: []cli.Flag{
-			utils.PBFTRequestTimeoutFlag,
-			utils.PBFTBlockPeriodFlag,
-			utils.PBFTBlockPauseTimeFlag,
-			utils.PBFTProposerPolicyFlag,
-			utils.PBFTCheckPointPeriodFlag,
+			utils.IstanbulRequestTimeoutFlag,
+			utils.IstanbulBlockPeriodFlag,
+			utils.IstanbulBlockPauseTimeFlag,
+			utils.IstanbulProposerPolicyFlag,
+			utils.IstanbulCheckPointPeriodFlag,
 		},
 	},
 }

cmd/utils/flags.go

@@ -32,7 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
-	"github.com/ethereum/go-ethereum/consensus/pbft"
+	"github.com/ethereum/go-ethereum/consensus/istanbul"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -424,31 +424,31 @@ var (
 		Value: eth.DefaultConfig.GPO.Percentile,
 	}
 
-	// PBFT settings
-	PBFTRequestTimeoutFlag = cli.Uint64Flag{
-		Name:  "pbft_request_timeout",
-		Usage: "The timeout for each PBFT round in millisecond",
-		Value: eth.DefaultConfig.PBFT.RequestTimeoutMsec,
+	// Istanbul settings
+	IstanbulRequestTimeoutFlag = cli.Uint64Flag{
+		Name:  "istanbul_request_timeout",
+		Usage: "The timeout for each Istanbul round in millisecond",
+		Value: eth.DefaultConfig.Istanbul.RequestTimeoutMsec,
 	}
-	PBFTBlockPeriodFlag = cli.Uint64Flag{
-		Name:  "pbft_block_period",
+	IstanbulBlockPeriodFlag = cli.Uint64Flag{
+		Name:  "istanbul_block_period",
 		Usage: "Default minimum difference between two consecutive block's timestamps in second",
-		Value: eth.DefaultConfig.PBFT.BlockPeriod,
+		Value: eth.DefaultConfig.Istanbul.BlockPeriod,
 	}
-	PBFTBlockPauseTimeFlag = cli.Uint64Flag{
-		Name:  "pbft_block_pause_time",
-		Usage: "Pause time when zero tx in previous block, values should be larger than pbft_block_period",
-		Value: eth.DefaultConfig.PBFT.BlockPauseTime,
+	IstanbulBlockPauseTimeFlag = cli.Uint64Flag{
+		Name:  "istanbul_block_pause_time",
+		Usage: "Pause time when zero tx in previous block, values should be larger than istanbul_block_period",
+		Value: eth.DefaultConfig.Istanbul.BlockPauseTime,
 	}
-	PBFTProposerPolicyFlag = cli.IntFlag{
-		Name:  "pbft_proposer_policy",
+	IstanbulProposerPolicyFlag = cli.IntFlag{
+		Name:  "istanbul_proposer_policy",
 		Usage: "The policy for proposer, the detail is not determined",
-		Value: int(eth.DefaultConfig.PBFT.ProposerPolicy),
+		Value: int(eth.DefaultConfig.Istanbul.ProposerPolicy),
 	}
-	PBFTCheckPointPeriodFlag = cli.IntFlag{
-		Name:  "pbft_cp_period",
+	IstanbulCheckPointPeriodFlag = cli.IntFlag{
+		Name:  "istanbul_cp_period",
 		Usage: "Synchronizes the mapping's checkpoint to the blocks on each round",
-		Value: eth.DefaultConfig.PBFT.CheckPointPeriod,
+		Value: eth.DefaultConfig.Istanbul.CheckPointPeriod,
 	}
 )
 
@@ -829,21 +829,21 @@ func setEthash(ctx *cli.Context, cfg *eth.Config) {
 	}
 }
 
-func setPBFT(ctx *cli.Context, cfg *eth.Config) {
-	if ctx.GlobalIsSet(PBFTRequestTimeoutFlag.Name) {
-		cfg.PBFT.RequestTimeoutMsec = ctx.GlobalUint64(PBFTRequestTimeoutFlag.Name)
+func setIstanbul(ctx *cli.Context, cfg *eth.Config) {
+	if ctx.GlobalIsSet(IstanbulRequestTimeoutFlag.Name) {
+		cfg.Istanbul.RequestTimeoutMsec = ctx.GlobalUint64(IstanbulRequestTimeoutFlag.Name)
 	}
-	if ctx.GlobalIsSet(PBFTBlockPeriodFlag.Name) {
-		cfg.PBFT.BlockPeriod = ctx.GlobalUint64(PBFTBlockPeriodFlag.Name)
+	if ctx.GlobalIsSet(IstanbulBlockPeriodFlag.Name) {
+		cfg.Istanbul.BlockPeriod = ctx.GlobalUint64(IstanbulBlockPeriodFlag.Name)
 	}
-	if ctx.GlobalIsSet(PBFTBlockPauseTimeFlag.Name) {
-		cfg.PBFT.BlockPauseTime = ctx.GlobalUint64(PBFTBlockPauseTimeFlag.Name)
+	if ctx.GlobalIsSet(IstanbulBlockPauseTimeFlag.Name) {
+		cfg.Istanbul.BlockPauseTime = ctx.GlobalUint64(IstanbulBlockPauseTimeFlag.Name)
 	}
-	if ctx.GlobalIsSet(PBFTProposerPolicyFlag.Name) {
-		cfg.PBFT.ProposerPolicy = pbft.ProposerPolicy(ctx.GlobalInt(PBFTProposerPolicyFlag.Name))
+	if ctx.GlobalIsSet(IstanbulProposerPolicyFlag.Name) {
+		cfg.Istanbul.ProposerPolicy = istanbul.ProposerPolicy(ctx.GlobalInt(IstanbulProposerPolicyFlag.Name))
 	}
-	if ctx.GlobalIsSet(PBFTCheckPointPeriodFlag.Name) {
-		cfg.PBFT.CheckPointPeriod = ctx.GlobalInt(PBFTCheckPointPeriodFlag.Name)
+	if ctx.GlobalIsSet(IstanbulCheckPointPeriodFlag.Name) {
+		cfg.Istanbul.CheckPointPeriod = ctx.GlobalInt(IstanbulCheckPointPeriodFlag.Name)
 	}
 }
 
@@ -869,7 +869,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
 	setEtherbase(ctx, ks, cfg)
 	setGPO(ctx, &cfg.GPO)
 	setEthash(ctx, cfg)
-	setPBFT(ctx, cfg)
+	setIstanbul(ctx, cfg)
 	switch {
 	case ctx.GlobalIsSet(SyncModeFlag.Name):
 		cfg.SyncMode = *GlobalTextMarshaler(ctx, SyncModeFlag.Name).(*downloader.SyncMode)

consensus/consensus.go

@@ -103,8 +103,8 @@ type PoW interface {
 	Hashrate() float64
 }
 
-// PBFT is a consensus engine to avoid byzantine failure
-type PBFT interface {
+// Istanbul is a consensus engine to avoid byzantine failure
+type Istanbul interface {
 	Engine
 
 	// Add a peer

consensus/pbft/backend.go renamed to consensus/istanbul/backend.go

@@ -14,14 +14,14 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-package pbft
+package istanbul
 
 import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/event"
 )
 
-// Backend provides application specific functions for PBFT core
+// Backend provides application specific functions for Istanbul core
 type Backend interface {
 	// Address returns self address
 	Address() common.Address
@@ -62,7 +62,7 @@ type Backend interface {
 	Persistence
 }
 
-// Persistence provides persistence data storage for PBFT core
+// Persistence provides persistence data storage for Istanbul core
 type Persistence interface {
 	// Save an object into database
 	Save(key string, val interface{}) error

consensus/pbft/backends/simple/api.go renamed to consensus/istanbul/backends/simple/api.go

@@ -24,7 +24,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// API is a user facing RPC API to dump PBFT state
+// API is a user facing RPC API to dump Istanbul state
 type API struct {
 	chain   consensus.ChainReader
 	backend *simpleBackend

consensus/pbft/backends/simple/backend.go renamed to consensus/istanbul/backends/simple/backend.go

@@ -22,8 +22,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
-	"github.com/ethereum/go-ethereum/consensus/pbft"
-	pbftCore "github.com/ethereum/go-ethereum/consensus/pbft/core"
+	"github.com/ethereum/go-ethereum/consensus/istanbul"
+	istanbulCore "github.com/ethereum/go-ethereum/consensus/istanbul/core"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -32,53 +32,53 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// New creates an Ethereum backend for PBFT core engine.
-func New(config *pbft.Config, eventMux *event.TypeMux, privateKey *ecdsa.PrivateKey, db ethdb.Database) consensus.PBFT {
+// New creates an Ethereum backend for Istanbul core engine.
+func New(config *istanbul.Config, eventMux *event.TypeMux, privateKey *ecdsa.PrivateKey, db ethdb.Database) consensus.Istanbul {
 	backend := &simpleBackend{
-		config:       config,
-		peerSet:      newPeerSet(),
-		eventMux:     eventMux,
-		pbftEventMux: new(event.TypeMux),
-		privateKey:   privateKey,
-		address:      crypto.PubkeyToAddress(privateKey.PublicKey),
-		logger:       log.New("backend", "simple"),
-		db:           db,
-		commitCh:     make(chan common.Hash, 1),
+		config:           config,
+		peerSet:          newPeerSet(),
+		eventMux:         eventMux,
+		istanbulEventMux: new(event.TypeMux),
+		privateKey:       privateKey,
+		address:          crypto.PubkeyToAddress(privateKey.PublicKey),
+		logger:           log.New("backend", "simple"),
+		db:               db,
+		commitCh:         make(chan common.Hash, 1),
 	}
 	return backend
 }
 
 // ----------------------------------------------------------------------------
 
 type simpleBackend struct {
-	config       *pbft.Config
-	peerSet      *peerSet
-	valSet       pbft.ValidatorSet
-	eventMux     *event.TypeMux
-	pbftEventMux *event.TypeMux
-	privateKey   *ecdsa.PrivateKey
-	address      common.Address
-	core         pbftCore.Engine
-	logger       log.Logger
-	quitSync     chan struct{}
-	db           ethdb.Database
-	timeout      uint64
-	chain        consensus.ChainReader
-	inserter     func(block *types.Block) error
-
-	// the channels for pbft engine notifications
+	config           *istanbul.Config
+	peerSet          *peerSet
+	valSet           istanbul.ValidatorSet
+	eventMux         *event.TypeMux
+	istanbulEventMux *event.TypeMux
+	privateKey       *ecdsa.PrivateKey
+	address          common.Address
+	core             istanbulCore.Engine
+	logger           log.Logger
+	quitSync         chan struct{}
+	db               ethdb.Database
+	timeout          uint64
+	chain            consensus.ChainReader
+	inserter         func(block *types.Block) error
+
+	// the channels for istanbul engine notifications
 	commitCh          chan common.Hash
 	proposedBlockHash common.Hash
 	sealMu            sync.Mutex
 }
 
-// Address implements pbft.Backend.Address
+// Address implements istanbul.Backend.Address
 func (sb *simpleBackend) Address() common.Address {
 	return sb.address
 }
 
-// Validators implements pbft.Backend.Validators
-func (sb *simpleBackend) Validators() pbft.ValidatorSet {
+// Validators implements istanbul.Backend.Validators
+func (sb *simpleBackend) Validators() istanbul.ValidatorSet {
 	return sb.valSet
 }
 
@@ -88,34 +88,34 @@ func (sb *simpleBackend) Send(payload []byte, target common.Address) error {
 		return errInvalidPeer
 	}
 
-	go sb.eventMux.Post(pbft.ConsensusDataEvent{
+	go sb.eventMux.Post(istanbul.ConsensusDataEvent{
 		PeerID: peer.ID(),
 		Data:   payload,
 	})
 	return nil
 }
 
-// Broadcast implements pbft.Backend.Send
+// Broadcast implements istanbul.Backend.Send
 func (sb *simpleBackend) Broadcast(payload []byte) error {
-	pbftMsg := pbft.MessageEvent{
+	istanbulMsg := istanbul.MessageEvent{
 		Payload: payload,
 	}
 
 	// send to self
-	go sb.pbftEventMux.Post(pbftMsg)
+	go sb.istanbulEventMux.Post(istanbulMsg)
 
 	// send to other peers
 	for _, peer := range sb.peerSet.List() {
-		go sb.eventMux.Post(pbft.ConsensusDataEvent{
+		go sb.eventMux.Post(istanbul.ConsensusDataEvent{
 			PeerID: peer.ID(),
 			Data:   payload,
 		})
 	}
 	return nil
 }
 
-// Commit implements pbft.Backend.Commit
-func (sb *simpleBackend) Commit(proposal pbft.Proposal) error {
+// Commit implements istanbul.Backend.Commit
+func (sb *simpleBackend) Commit(proposal istanbul.Proposal) error {
 	// Check if the proposal is a valid block
 	block := &types.Block{}
 	block, ok := proposal.(*types.Block)
@@ -148,13 +148,13 @@ func (sb *simpleBackend) NextRound() error {
 	return nil
 }
 
-// EventMux implements pbft.Backend.EventMux
+// EventMux implements istanbul.Backend.EventMux
 func (sb *simpleBackend) EventMux() *event.TypeMux {
-	return sb.pbftEventMux
+	return sb.istanbulEventMux
 }
 
-// Verify implements pbft.Backend.Verify
-func (sb *simpleBackend) Verify(proposal pbft.Proposal) error {
+// Verify implements istanbul.Backend.Verify
+func (sb *simpleBackend) Verify(proposal istanbul.Proposal) error {
 	// Check if the proposal is a valid block
 	block := &types.Block{}
 	block, ok := proposal.(*types.Block)
@@ -166,13 +166,13 @@ func (sb *simpleBackend) Verify(proposal pbft.Proposal) error {
 	return sb.VerifyHeader(sb.chain, block.Header(), false)
 }
 
-// Sign implements pbft.Backend.Sign
+// Sign implements istanbul.Backend.Sign
 func (sb *simpleBackend) Sign(data []byte) ([]byte, error) {
 	hashData := crypto.Keccak256([]byte(data))
 	return crypto.Sign(hashData, sb.privateKey)
 }
 
-// CheckSignature implements pbft.Backend.CheckSignature
+// CheckSignature implements istanbul.Backend.CheckSignature
 func (sb *simpleBackend) CheckSignature(data []byte, address common.Address, sig []byte) error {
 	signer, err := sb.getSignatureAddress(data, sig)
 	if err != nil {
@@ -186,7 +186,7 @@ func (sb *simpleBackend) CheckSignature(data []byte, address common.Address, sig
 	return nil
 }
 
-// CheckValidatorSignature implements pbft.Backend.CheckValidatorSignature
+// CheckValidatorSignature implements istanbul.Backend.CheckValidatorSignature
 func (sb *simpleBackend) CheckValidatorSignature(data []byte, sig []byte) (common.Address, error) {
 	// 1. Get signature address
 	signer, err := sb.getSignatureAddress(data, sig)
@@ -200,7 +200,7 @@ func (sb *simpleBackend) CheckValidatorSignature(data []byte, sig []byte) (commo
 		return val.Address(), nil
 	}
 
-	return common.Address{}, pbft.ErrUnauthorizedAddress
+	return common.Address{}, istanbul.ErrUnauthorizedAddress
 }
 
 // get the signer address from the signature