replace SYS_EXIT with log.Fatal (#572)

iotexproject · Jun 28, 2018 · 7fac6df · 7fac6df
1 parent ea83116
commit 7fac6df
Show file tree

Hide file tree

Showing 5 changed files with 39 additions and 32 deletions.
diff --git a/blocksync/blocksync.go b/blocksync/blocksync.go
@@ -7,9 +7,9 @@
 package blocksync
 
 import (
+	"errors"
 	"fmt"
 	"sync"
-	"syscall"
 	"time"
 
 	"github.com/iotexproject/iotex-core/actpool"
@@ -80,8 +80,8 @@ func SyncTaskInterval(cfg *config.Config) time.Duration {
 }
 
 // NewBlockSyncer returns a new block syncer instance
-func NewBlockSyncer(cfg *config.Config, chain bc.Blockchain, ap actpool.ActPool, p2p *network.Overlay, dp delegate.Pool) BlockSync {
-	sync := &blockSyncer{
+func NewBlockSyncer(cfg *config.Config, chain bc.Blockchain, ap actpool.ActPool, p2p *network.Overlay, dp delegate.Pool) (BlockSync, error) {
+	bs := &blockSyncer{
 		state:      Idle,
 		rcvdBlocks: map[uint64]*bc.Block{},
 		sw:         NewSlidingWindow(),
@@ -90,40 +90,37 @@ func NewBlockSyncer(cfg *config.Config, chain bc.Blockchain, ap actpool.ActPool,
 		p2p:        p2p,
 		dp:         dp}
 
-	sync.ackBlockCommit = cfg.IsDelegate() || cfg.IsFullnode()
-	sync.ackBlockSync = cfg.IsDelegate() || cfg.IsFullnode()
-	sync.ackSyncReq = cfg.IsDelegate() || cfg.IsFullnode()
+	bs.ackBlockCommit = cfg.IsDelegate() || cfg.IsFullnode()
+	bs.ackBlockSync = cfg.IsDelegate() || cfg.IsFullnode()
+	bs.ackSyncReq = cfg.IsDelegate() || cfg.IsFullnode()
 
 	if interval := SyncTaskInterval(cfg); interval != 0 {
-		sync.task = routine.NewRecurringTask(sync, interval)
+		bs.task = routine.NewRecurringTask(bs, interval)
 	}
 
 	delegates, err := dp.AllDelegates()
-	if err != nil || len(delegates) == 0 {
-		if err != nil {
-			logger.Error().Err(err)
-		} else {
-			logger.Error().Msg("No delegates found")
-		}
-		syscall.Exit(syscall.SYS_EXIT)
+	if err != nil {
+		return nil, err
+	}
+	if len(delegates) == 0 {
+		return nil, errors.New("No delegates found")
 	}
 
 	switch cfg.NodeType {
 	case config.DelegateType:
 		// pick a delegate that is not myself
 		if dlg := dp.AnotherDelegate(p2p.PRC.Addr); dlg != nil {
-			sync.fnd = dlg.String()
+			bs.fnd = dlg.String()
 		}
 	case config.FullNodeType:
 		// pick any valid delegate
 		if dlg := dp.AnotherDelegate(""); dlg != nil {
-			sync.fnd = dlg.String()
+			bs.fnd = dlg.String()
 		}
 	default:
-		logger.Error().Str("node_type", cfg.NodeType).Msg("Unexpected node type.")
-		return nil
+		return nil, errors.New("Unexpected node type: " + cfg.NodeType)
 	}
-	return sync
+	return bs, nil
 }
 
 // P2P returns the network overlay object

diff --git a/blocksync/blocksync_test.go b/blocksync/blocksync_test.go
@@ -96,23 +96,26 @@ func TestNewBlockSyncer(t *testing.T) {
 		NodeType: config.LightweightType,
 	}
 
-	bsLightWeight := NewBlockSyncer(cfgLightWeight, nil, nil, p2p, mPool)
+	bsLightWeight, err := NewBlockSyncer(cfgLightWeight, nil, nil, p2p, mPool)
+	assert.NotNil(err)
 	assert.Nil(bsLightWeight)
 
 	// Delegate
 	cfgDelegate := &config.Config{
 		NodeType: config.DelegateType,
 	}
 
-	bsDelegate := NewBlockSyncer(cfgDelegate, nil, nil, p2p, mPool)
+	bsDelegate, err := NewBlockSyncer(cfgDelegate, nil, nil, p2p, mPool)
+	assert.Nil(err)
 	assert.Equal("123", bsDelegate.(*blockSyncer).fnd)
 
 	// FullNode
 	cfgFullNode := &config.Config{
 		NodeType: config.FullNodeType,
 	}
 
-	bsFullNode := NewBlockSyncer(cfgFullNode, nil, nil, p2p, mPool)
+	bsFullNode, err := NewBlockSyncer(cfgFullNode, nil, nil, p2p, mPool)
+	assert.Nil(err)
 	assert.Equal("123", bsFullNode.(*blockSyncer).fnd)
 }
 
@@ -131,7 +134,8 @@ func TestBlockSyncer_P2P(t *testing.T) {
 	cfgFullNode := &config.Config{
 		NodeType: config.FullNodeType,
 	}
-	bs := NewBlockSyncer(cfgFullNode, nil, nil, p2p, mPool)
+	bs, err := NewBlockSyncer(cfgFullNode, nil, nil, p2p, mPool)
+	assert.Nil(err)
 	assert.Equal(p2p, bs.P2P())
 }
 
@@ -175,7 +179,8 @@ func TestBlockSyncer_ProcessSyncRequest(t *testing.T) {
 		NodeType: config.FullNodeType,
 	}
 
-	bs := NewBlockSyncer(cfgFullNode, mBc, nil, p2p, mPool)
+	bs, err := NewBlockSyncer(cfgFullNode, mBc, nil, p2p, mPool)
+	assert.Nil(err)
 
 	pbBs := &pb.BlockSync{
 		Start: 1,
@@ -205,7 +210,8 @@ func TestBlockSyncer_ProcessBlock_TipHeightError(t *testing.T) {
 		NodeType: config.FullNodeType,
 	}
 
-	bs := NewBlockSyncer(cfgFullNode, mBc, nil, p2p, mPool)
+	bs, err := NewBlockSyncer(cfgFullNode, mBc, nil, p2p, mPool)
+	assert.Nil(err)
 	blk := bc.NewBlock(uint32(123), uint64(4), common.Hash32B{}, nil, nil)
 	bs.(*blockSyncer).ackBlockCommit = false
 	assert.Nil(bs.ProcessBlock(blk))
@@ -239,7 +245,8 @@ func TestBlockSyncer_ProcessBlock_TipHeight(t *testing.T) {
 		NodeType: config.FullNodeType,
 	}
 
-	bs := NewBlockSyncer(cfgFullNode, mBc, ap, p2p, mPool)
+	bs, err := NewBlockSyncer(cfgFullNode, mBc, ap, p2p, mPool)
+	assert.Nil(err)
 	blk := bc.NewBlock(uint32(123), uint64(4), common.Hash32B{}, nil, nil)
 
 	bs.(*blockSyncer).ackBlockCommit = true
@@ -286,7 +293,8 @@ func TestBlockSyncer_ProcessBlockSync(t *testing.T) {
 		NodeType: config.FullNodeType,
 	}
 
-	bs := NewBlockSyncer(cfgFullNode, mBc, ap, p2p, mPool)
+	bs, err := NewBlockSyncer(cfgFullNode, mBc, ap, p2p, mPool)
+	assert.Nil(err)
 	blk := bc.NewBlock(uint32(123), uint64(4), common.Hash32B{}, nil, nil)
 	bs.(*blockSyncer).ackBlockSync = false
 	assert.Nil(bs.ProcessBlockSync(blk))

diff --git a/network/overlay.go b/network/overlay.go
@@ -8,7 +8,6 @@ package network
 
 import (
 	"net"
-	"syscall"
 
 	"github.com/golang/protobuf/proto"
 	"github.com/pkg/errors"
@@ -89,8 +88,7 @@ func (o *Overlay) addPeerMaintainer() {
 func (o *Overlay) addConfigBasedPeerMaintainer() {
 	topology, err := config.LoadTopology(o.Config.TopologyPath)
 	if err != nil {
-		logger.Error().Err(err)
-		syscall.Exit(syscall.SYS_EXIT)
+		logger.Fatal().Err(err)
 	}
 	cbpm := NewConfigBasedPeerMaintainer(o, topology)
 	cbpmTask := routine.NewRecurringTask(cbpm, o.Config.PeerMaintainerInterval)

diff --git a/server/itx/itxserver.go b/server/itx/itxserver.go
@@ -104,7 +104,11 @@ func newServer(cfg config.Config, bc blockchain.Blockchain, sf state.Factory) *S
 	// Create ActPool
 	ap := actpool.NewActPool(sf)
 	pool := delegate.NewConfigBasedPool(&cfg.Delegate)
-	bs := blocksync.NewBlockSyncer(&cfg, bc, ap, o, pool)
+	bs, err := blocksync.NewBlockSyncer(&cfg, bc, ap, o, pool)
+	if err != nil {
+		logger.Fatal().Err(err)
+	}
+
 	// create dispatcher instance
 	dp := dispatch.NewDispatcher(&cfg, bc, ap, bs, pool, sf)
 	o.AttachDispatcher(dp)

diff --git a/simulator/consensus_sim_server.go b/simulator/consensus_sim_server.go
@@ -113,7 +113,7 @@ func (s *server) Init(in *pb.InitRequest, stream pb.Simulator_InitServer) error
 		overlay := network.NewOverlay(&cfg.Network)
 		ap := actpool.NewActPool(sf)
 		dlg := delegate.NewConfigBasedPool(&cfg.Delegate)
-		bs := blocksync.NewBlockSyncer(cfg, bc, ap, overlay, dlg)
+		bs, _ := blocksync.NewBlockSyncer(cfg, bc, ap, overlay, dlg)
 		bs.Start()
 
 		var node consensus.Sim