modify

diff --git a/cmd/reward/command/init.go b/cmd/reward/command/init.go
index f7e3f8a..b391d7a 100644 (file)
--- a/cmd/reward/command/init.go
+++ b/cmd/reward/command/init.go
@@ -31,7 +31,7 @@ func initFiles(cmd *cobra.Command, args []string) {
                log.WithFields(log.Fields{"module": logModule, "config": configFilePath}).Fatal("Already exists config file.")
        }
 
-       if err := cfg.ExportFederationFile(configFilePath, config); err != nil {
+       if err := cfg.ExportConfigFile(configFilePath, config); err != nil {
                log.WithFields(log.Fields{"module": logModule, "config": configFilePath, "error": err}).Fatal("fail on export reward file")
        }
 

diff --git a/cmd/reward/command/run.go b/cmd/reward/command/run.go
index 328fd0d..6b7a23a 100644 (file)
--- a/cmd/reward/command/run.go
+++ b/cmd/reward/command/run.go
@@ -45,32 +45,32 @@ func runReward(cmd *cobra.Command, args []string) error {
        startTime := time.Now()
        configFilePath := cfg.ConfigFile()
        config := &cfg.Config{}
-       if err := cfg.LoadFederationFile(configFilePath, config); err != nil {
-               cmn.Exit(cmn.Fmt("Failed to load reward information:[%s]", err.Error()))
+       if err := cfg.LoadConfigFile(configFilePath, config); err != nil {
+               log.WithFields(log.Fields{"module": logModule, "config": configFilePath, "error": err}).Fatal("Failded to load config file.")
        }
 
        initActiveNetParams(config)
        if rewardStartHeight >= rewardEndHeight || rewardStartHeight%consensus.ActiveNetParams.RoundVoteBlockNums != 0 || rewardEndHeight%consensus.ActiveNetParams.RoundVoteBlockNums != 0 {
-               cmn.Exit("Please check the height range, which must be multiple of the number of block rounds")
+               log.Fatal("Please check the height range, which must be multiple of the number of block rounds.")
        }
 
        db, err := common.NewMySQLDB(config.MySQLConfig)
        if err != nil {
-               cmn.Exit(cmn.Fmt("initialize mysql db error:[%s]", err.Error()))
+               log.WithFields(log.Fields{"module": logModule, "error": err}).Fatal("Failded to initialize mysql db.")
        }
 
        sync, err := synchron.NewChainKeeper(db, config, rewardEndHeight)
        if err != nil {
-               cmn.Exit(cmn.Fmt("initialize NewChainKeeper error:[%s]", err.Error()))
+               log.WithFields(log.Fields{"module": logModule, "error": err}).Fatal("Failded to initialize NewChainKeeper.")
        }
 
        if err := sync.Start(); err != nil {
-               cmn.Exit(cmn.Fmt("Failded to sync block:[%s]", err.Error()))
+               log.WithFields(log.Fields{"module": logModule, "error": err}).Fatal("Failded to sync block.")
        }
 
        r := reward.NewReward(db, config, rewardStartHeight, rewardEndHeight)
        if err := r.Start(); err != nil {
-               cmn.Exit(cmn.Fmt("Failded to send reward:[%s]", err.Error()))
+               log.WithFields(log.Fields{"module": logModule, "error": err}).Fatal("Failded to send reward.")
        }
 
        log.WithFields(log.Fields{

diff --git a/toolbar/reward/config/config.go b/toolbar/reward/config/config.go
index 835f4eb..1ed36a7 100644 (file)
--- a/toolbar/reward/config/config.go
+++ b/toolbar/reward/config/config.go
@@ -11,10 +11,10 @@ import (
 )
 
 type Config struct {
-       MySQLConfig      common.MySQLConfig        `json:"mysql"`
-       Chain            Chain                     `json:"chain"`
-       VoteConf         *VoteRewardConfig         `json:"vote_reward"`
-       OptionalNodeConf *OptionalNodeRewardConfig `json:"optional_node_reward"`
+       MySQLConfig         common.MySQLConfig           `json:"mysql"`
+       Chain               Chain                        `json:"chain"`
+       VoteConf            *VoteRewardConfig            `json:"vote_reward"`
+       AlternativeNodeConf *AlternativeNodeRewardConfig `json:"alternative_node_reward"`
 }
 
 func DefaultConfig(isVoterReward bool) *Config {
@@ -24,7 +24,7 @@ func DefaultConfig(isVoterReward bool) *Config {
                }
        }
        return &Config{
-               OptionalNodeConf: DefaultOptionalNodeRewardConfig(),
+               AlternativeNodeConf: DefaultAlternativeNodeRewardConfig(),
        }
 }
 
@@ -48,7 +48,7 @@ type VoteRewardConfig struct {
        MiningAddress string `json:"mining_adress"`
 }
 
-type OptionalNodeRewardConfig struct {
+type AlternativeNodeRewardConfig struct {
        TotalReward uint64 `json:"total_reward"`
 }
 
@@ -58,13 +58,13 @@ func DefaultVoteRewardConfig() *VoteRewardConfig {
        }
 }
 
-func DefaultOptionalNodeRewardConfig() *OptionalNodeRewardConfig {
-       return &OptionalNodeRewardConfig{
+func DefaultAlternativeNodeRewardConfig() *AlternativeNodeRewardConfig {
+       return &AlternativeNodeRewardConfig{
                TotalReward: 30,
        }
 }
 
-func ExportFederationFile(fedFile string, config *Config) error {
+func ExportConfigFile(fedFile string, config *Config) error {
        buf := new(bytes.Buffer)
 
        encoder := json.NewEncoder(buf)
@@ -76,7 +76,7 @@ func ExportFederationFile(fedFile string, config *Config) error {
        return ioutil.WriteFile(fedFile, buf.Bytes(), 0644)
 }
 
-func LoadFederationFile(fedFile string, config *Config) error {
+func LoadConfigFile(fedFile string, config *Config) error {
        file, err := os.Open(fedFile)
        if err != nil {
                return err

diff --git a/toolbar/reward/rewardinstance/vote_reward.go b/toolbar/reward/rewardinstance/vote_reward.go
index 454c602..650f908 100644 (file)
--- a/toolbar/reward/rewardinstance/vote_reward.go
+++ b/toolbar/reward/rewardinstance/vote_reward.go
@@ -73,7 +73,6 @@ func (v *Vote) Start() error {
        for height := v.rewardStartHeight + v.roundVoteBlockNums; height <= v.rewardEndHeight; height += v.roundVoteBlockNums {
                voteInfo, err := v.getVoteByXpub(height)
                if err != nil {
-                       log.WithFields(log.Fields{"error": err, "coinbase_height": height}).Error("get vote from db")
                        return errors.Wrapf(err, "get vote from db at coinbase_height: %d", height)
                }
 
@@ -92,14 +91,12 @@ func (v *Vote) calcCoinbaseReward() error {
                coinbaseHeight := height + 1
                coinbaseTx, err := v.node.GetCoinbaseTx(coinbaseHeight)
                if err != nil {
-                       log.WithFields(log.Fields{"error": err, "coinbase_height": coinbaseHeight}).Error("get coinbase reward")
                        return errors.Wrapf(err, "get coinbase reward at coinbase_height: %d", coinbaseHeight)
                }
 
                for _, output := range coinbaseTx.Outputs {
                        output, ok := output.TypedOutput.(*types.IntraChainOutput)
                        if !ok {
-                               log.WithFields(log.Fields{"error": err, "coinbase_height": coinbaseHeight}).Error("Output type error")
                                return errors.New("Output type error")
                        }
 
@@ -193,7 +190,6 @@ func (v *Vote) sendRewardTransaction() error {
        outputAction := strings.Join(outputActions, ",")
        txID, err := v.node.SendTransaction(inputAction, outputAction, v.nodeConfig.Passwd)
        if err != nil {
-               log.WithFields(log.Fields{"error": err, "node": v.nodeConfig}).Error("send reward transaction")
                return err
        }
 

diff --git a/toolbar/reward/synchron/block_keeper.go b/toolbar/reward/synchron/block_keeper.go
index 7d943cc..524623b 100644 (file)
--- a/toolbar/reward/synchron/block_keeper.go
+++ b/toolbar/reward/synchron/block_keeper.go
@@ -31,22 +31,20 @@ func NewChainKeeper(db *gorm.DB, cfg *config.Config, syncHeight uint64) (*ChainK
        }
 
        blockState := &orm.BlockState{}
-       if err := db.First(blockState).Error; err != nil {
-               if err == gorm.ErrRecordNotFound {
-                       blockStr, _, err := keeper.node.GetBlockByHeight(0)
-                       if err != nil {
-                               return nil, errors.Wrap(err, "Failed to get genenis block")
-                       }
-                       block := &types.Block{}
-                       if err := block.UnmarshalText([]byte(blockStr)); err != nil {
-                               return nil, errors.Wrap(err, "unmarshal block")
-                       }
-                       if err := keeper.insertBlockState(db, block); err != nil {
-                               return nil, errors.Wrap(err, "Failed to insert blockState")
-                       }
-               } else {
-                       return nil, errors.Wrap(err, "Failed to get blockState")
+       if err := db.First(blockState).Error; err == gorm.ErrRecordNotFound {
+               blockStr, _, err := keeper.node.GetBlockByHeight(0)
+               if err != nil {
+                       return nil, errors.Wrap(err, "Failed to get genenis block")
+               }
+               block := &types.Block{}
+               if err := block.UnmarshalText([]byte(blockStr)); err != nil {
+                       return nil, errors.Wrap(err, "unmarshal block")
+               }
+               if err := keeper.initBlockState(db, block); err != nil {
+                       return nil, errors.Wrap(err, "Failed to insert blockState")
                }
+       } else if err != nil {
+               return nil, errors.Wrap(err, "Failed to get blockState")
        }
 
        return keeper, nil
@@ -56,7 +54,6 @@ func (c *ChainKeeper) Start() error {
        for {
                blockState := &orm.BlockState{}
                if c.db.First(blockState).RecordNotFound() {
-                       log.Errorln("The query blockState record is empty empty on process block")
                        return errors.New("The query blockState record is empty empty on process block")
                }
 
@@ -65,7 +62,6 @@ func (c *ChainKeeper) Start() error {
                }
 
                if err := c.syncBlock(blockState); err != nil {
-                       log.WithField("error", err).Errorln("blockKeeper fail on process block")
                        return err
                }
        }
@@ -224,7 +220,7 @@ func (c *ChainKeeper) DetachBlock(block *types.Block, txStatus *bc.TransactionSt
        return ormDB.Commit().Error
 }
 
-func (c *ChainKeeper) insertBlockState(db *gorm.DB, block *types.Block) error {
+func (c *ChainKeeper) initBlockState(db *gorm.DB, block *types.Block) error {
        blockHash := block.Hash()
        blockState := &orm.BlockState{
                Height:    block.Height,