Merge pull request #79 from binance-chain/release/v0.30.1-binance.4

rickyyangz · web-flow · commit eec92053e38f · 2019-04-12T17:25:52.000+08:00
prepare for releasing v0.30.1 binance.4
diff --git a/config/config.go b/config/config.go
@@ -7,6 +7,8 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/syndtr/goleveldb/leveldb/filter"
+	optPkg "github.com/syndtr/goleveldb/leveldb/opt"
 )
 
 const (
@@ -63,6 +65,7 @@ type Config struct {
 	// Options for services
 	RPC             *RPCConfig             `mapstructure:"rpc"`
 	P2P             *P2PConfig             `mapstructure:"p2p"`
+	DBCache         *DBCacheConfig         `mapstructure:"dbcache"`
 	Mempool         *MempoolConfig         `mapstructure:"mempool"`
 	Consensus       *ConsensusConfig       `mapstructure:"consensus"`
 	TxIndex         *TxIndexConfig         `mapstructure:"tx_index"`
@@ -75,6 +78,7 @@ func DefaultConfig() *Config {
 		BaseConfig:      DefaultBaseConfig(),
 		RPC:             DefaultRPCConfig(),
 		P2P:             DefaultP2PConfig(),
+		DBCache:         DefaultDBCacheConfig(),
 		Mempool:         DefaultMempoolConfig(),
 		Consensus:       DefaultConsensusConfig(),
 		TxIndex:         DefaultTxIndexConfig(),
@@ -88,6 +92,7 @@ func TestConfig() *Config {
 		BaseConfig:      TestBaseConfig(),
 		RPC:             TestRPCConfig(),
 		P2P:             TestP2PConfig(),
+		DBCache:         TestDBCacheConfig(),
 		Mempool:         TestMempoolConfig(),
 		Consensus:       TestConsensusConfig(),
 		TxIndex:         TestTxIndexConfig(),
@@ -117,6 +122,9 @@ func (cfg *Config) ValidateBasic() error {
 	if err := cfg.P2P.ValidateBasic(); err != nil {
 		return errors.Wrap(err, "Error in [p2p] section")
 	}
+	if err := cfg.DBCache.ValidateBasic(); err != nil {
+		return errors.Wrap(err, "Error in [dbcache] section")
+	}
 	if err := cfg.Mempool.ValidateBasic(); err != nil {
 		return errors.Wrap(err, "Error in [mempool] section")
 	}
@@ -477,11 +485,11 @@ func DefaultP2PConfig() *P2PConfig {
 		MaxNumOutboundPeers:     10,
 		FlushThrottleTimeout:    10 * time.Millisecond,
 		MaxPacketMsgPayloadSize: 1024 * 1024,      // 1 MB
-		KeysPerRequest:		     2500,			   // would be around 250K for account node
+		KeysPerRequest:          2500,             // would be around 250K for account node
 		SendRate:                50 * 1024 * 1024, // 50 MB/s
 		RecvRate:                50 * 1024 * 1024, // 50 MB/s
-		PingInterval:  			 60 * time.Second,
-		PongTimeout:			 45 * time.Second,
+		PingInterval:            60 * time.Second,
+		PongTimeout:             45 * time.Second,
 		PexReactor:              true,
 		SeedMode:                false,
 		AllowDuplicateIP:        false,
@@ -551,6 +559,73 @@ func DefaultFuzzConnConfig() *FuzzConnConfig {
 	}
 }
 
+//-----------------------------------------------------------------------------
+// DBCacheConfig defines the cache related configuration (should not impact back compatibility) options of goleveldb
+type DBCacheConfig struct {
+	// OpenFilesCacheCapacity defines the capacity of the open files caching.
+	OpenFilesCacheCapacity int `mapstructure:"open_files_cache_capacity"`
+
+	// BlockCacheCapacity defines the capacity of the 'sorted table' block caching.
+	BlockCacheCapacity int `mapstructure:"block_cache_capacity"`
+
+	// WriteBuffer defines maximum size of a 'memdb' before flushed to
+	// 'sorted table'.
+	WriteBuffer int `mapstructure:"write_buffer"`
+
+	// Filter defines an 'effective filter' to use. An 'effective filter'
+	// if defined will be used to generate per-table filter block.
+	// Greater than 0 would creates a new initialized bloom filter for given bitsPerKey.
+	BitsPerKey int `mapstructure:"bits_per_key"`
+}
+
+// DefaultDBCacheConfig returns a default configuration for goleveldb config
+func DefaultDBCacheConfig() *DBCacheConfig {
+	return &DBCacheConfig{
+		OpenFilesCacheCapacity: 1024,
+		BlockCacheCapacity:     8 * optPkg.MiB,
+		WriteBuffer:            4 * optPkg.MiB,
+		BitsPerKey:             10,
+	}
+}
+
+// TestDBCacheConfig returns a configuration for testing
+func TestDBCacheConfig() *DBCacheConfig {
+	cfg := DefaultDBCacheConfig()
+	cfg.OpenFilesCacheCapacity = 500
+	cfg.BlockCacheCapacity = 8 * optPkg.MiB
+	cfg.WriteBuffer = 4 * optPkg.MiB
+	cfg.BitsPerKey = 0
+	return cfg
+}
+
+// ValidateBasic performs basic validation (checking param bounds, etc.) and
+// returns an error if any check fails.
+func (cfg *DBCacheConfig) ValidateBasic() error {
+	if cfg.OpenFilesCacheCapacity < 0 {
+		return errors.New("open_files_cache_capacity can't be negative")
+	}
+	if cfg.BlockCacheCapacity < 0 {
+		return errors.New("block_cache_capacity can't be negative")
+	}
+	if cfg.WriteBuffer < 0 {
+		return errors.New("write_buffer can't be negative")
+	}
+	return nil
+}
+
+func (cfg *DBCacheConfig) ToGolevelDBOpt() *optPkg.Options {
+	var fltr filter.Filter
+	if cfg.BitsPerKey > 0 {
+		fltr = filter.NewBloomFilter(cfg.BitsPerKey)
+	}
+	return &optPkg.Options{
+		OpenFilesCacheCapacity: cfg.OpenFilesCacheCapacity,
+		BlockCacheCapacity:     cfg.BlockCacheCapacity,
+		WriteBuffer:            cfg.WriteBuffer,
+		Filter:                 fltr,
+	}
+}
+
 //-----------------------------------------------------------------------------
 // MempoolConfig
 
diff --git a/config/toml.go b/config/toml.go
@@ -251,6 +251,22 @@ allow_duplicate_ip = {{ .P2P.AllowDuplicateIP }}
 handshake_timeout = "{{ .P2P.HandshakeTimeout }}"
 dial_timeout = "{{ .P2P.DialTimeout }}"
 
+##### dbcache configuration options #####
+[dbcache]
+# OpenFilesCacheCapacity defines the capacity of the open files caching.
+open_files_cache_capacity = {{ .DBCache.OpenFilesCacheCapacity }}
+
+# BlockCacheCapacity defines the capacity of the 'sorted table' block caching.
+block_cache_capacity = {{ .DBCache.BlockCacheCapacity }}
+
+# WriteBuffer defines maximum size of a 'memdb' before flushed to 'sorted table'.
+write_buffer = {{ .DBCache.WriteBuffer }}
+
+# Filter defines an 'effective filter' to use. An 'effective filter'
+# if defined will be used to generate per-table filter block.
+# Greater than 0 would creates a new initialized bloom filter for given bitsPerKey.
+bits_per_key = {{ .DBCache.BitsPerKey }}
+
 ##### mempool configuration options #####
 [mempool]
 
diff --git a/libs/db/backend_test.go b/libs/db/backend_test.go
@@ -60,7 +60,7 @@ func TestBackendsGetSetDelete(t *testing.T) {
 func withDB(t *testing.T, creator dbCreator, fn func(DB)) {
 	name := fmt.Sprintf("test_%x", cmn.RandStr(12))
 	dir := os.TempDir()
-	db, err := creator(name, dir)
+	db, err := creator(name, dir, nil)
 	require.Nil(t, err)
 	defer cleanupDBDir(dir, name)
 	fn(db)
diff --git a/libs/db/c_level_db.go b/libs/db/c_level_db.go
@@ -11,7 +11,7 @@ import (
 )
 
 func init() {
-	dbCreator := func(name string, dir string) (DB, error) {
+	dbCreator := func(name string, dir string, opt interface{}) (DB, error) {
 		return NewCLevelDB(name, dir)
 	}
 	registerDBCreator(LevelDBBackend, dbCreator, true)
diff --git a/libs/db/db.go b/libs/db/db.go
@@ -18,7 +18,7 @@ const (
 	FSDBBackend      DBBackendType = "fsdb" // using the filesystem naively
 )
 
-type dbCreator func(name string, dir string) (DB, error)
+type dbCreator func(name string, dir string, opt interface{}) (DB, error)
 
 var backends = map[DBBackendType]dbCreator{}
 
@@ -35,6 +35,15 @@ func registerDBCreator(backend DBBackendType, creator dbCreator, force bool) {
 //   - backend is unknown (not registered)
 //   - creator function, provided during registration, returns error
 func NewDB(name string, backend DBBackendType, dir string) DB {
+	return NewDBWithOpt(name, backend, dir, nil)
+}
+
+
+// NewDB creates a new database of type backend with the given name.
+// NOTE: function panics if:
+//   - backend is unknown (not registered)
+//   - creator function, provided during registration, returns error
+func NewDBWithOpt(name string, backend DBBackendType, dir string, opt interface{}) DB {
 	dbCreator, ok := backends[backend]
 	if !ok {
 		keys := make([]string, len(backends))
@@ -46,7 +55,7 @@ func NewDB(name string, backend DBBackendType, dir string) DB {
 		panic(fmt.Sprintf("Unknown db_backend %s, expected either %s", backend, strings.Join(keys, " or ")))
 	}
 
-	db, err := dbCreator(name, dir)
+	db, err := dbCreator(name, dir, opt)
 	if err != nil {
 		panic(fmt.Sprintf("Error initializing DB: %v", err))
 	}
diff --git a/libs/db/fsdb.go b/libs/db/fsdb.go
@@ -20,7 +20,7 @@ const (
 )
 
 func init() {
-	registerDBCreator(FSDBBackend, func(name string, dir string) (DB, error) {
+	registerDBCreator(FSDBBackend, func(name string, dir string, opt interface{}) (DB, error) {
 		dbPath := filepath.Join(dir, name+".db")
 		return NewFSDB(dbPath), nil
 	}, false)
diff --git a/libs/db/go_level_db.go b/libs/db/go_level_db.go
@@ -7,16 +7,19 @@ import (
 
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/errors"
-	"github.com/syndtr/goleveldb/leveldb/filter"
 	"github.com/syndtr/goleveldb/leveldb/iterator"
-	"github.com/syndtr/goleveldb/leveldb/opt"
+	optPkg "github.com/syndtr/goleveldb/leveldb/opt"
 
 	cmn "github.com/tendermint/tendermint/libs/common"
 )
 
 func init() {
-	dbCreator := func(name string, dir string) (DB, error) {
-		return NewGoLevelDB(name, dir)
+	dbCreator := func(name string, dir string, opt interface{}) (DB, error) {
+		if o, ok := opt.(*optPkg.Options); ok {
+			return NewGoLevelDBWithOpts(name, dir, o)
+		} else {
+			return NewGoLevelDB(name, dir)
+		}
 	}
 	registerDBCreator(LevelDBBackend, dbCreator, false)
 	registerDBCreator(GoLevelDBBackend, dbCreator, false)
@@ -29,14 +32,10 @@ type GoLevelDB struct {
 }
 
 func NewGoLevelDB(name string, dir string) (*GoLevelDB, error) {
-	var defaultOptions = &opt.Options{OpenFilesCacheCapacity: 1024,
-		BlockCacheCapacity: 2 * opt.GiB,
-		WriteBuffer:        768 / 4 * opt.MiB, // Two of these are used internally
-		Filter:             filter.NewBloomFilter(10)}
-	return NewGoLevelDBWithOpts(name, dir, defaultOptions)
+	return NewGoLevelDBWithOpts(name, dir, nil)
 }
 
-func NewGoLevelDBWithOpts(name string, dir string, o *opt.Options) (*GoLevelDB, error) {
+func NewGoLevelDBWithOpts(name string, dir string, o *optPkg.Options) (*GoLevelDB, error) {
 	dbPath := filepath.Join(dir, name+".db")
 	db, err := leveldb.OpenFile(dbPath, o)
 	if err != nil {
@@ -80,7 +79,7 @@ func (db *GoLevelDB) Set(key []byte, value []byte) {
 func (db *GoLevelDB) SetSync(key []byte, value []byte) {
 	key = nonNilBytes(key)
 	value = nonNilBytes(value)
-	err := db.db.Put(key, value, &opt.WriteOptions{Sync: true})
+	err := db.db.Put(key, value, &optPkg.WriteOptions{Sync: true})
 	if err != nil {
 		cmn.PanicCrisis(err)
 	}
@@ -98,7 +97,7 @@ func (db *GoLevelDB) Delete(key []byte) {
 // Implements DB.
 func (db *GoLevelDB) DeleteSync(key []byte) {
 	key = nonNilBytes(key)
-	err := db.db.Delete(key, &opt.WriteOptions{Sync: true})
+	err := db.db.Delete(key, &optPkg.WriteOptions{Sync: true})
 	if err != nil {
 		cmn.PanicCrisis(err)
 	}
@@ -175,15 +174,15 @@ func (mBatch *goLevelDBBatch) Delete(key []byte) {
 
 // Implements Batch.
 func (mBatch *goLevelDBBatch) Write() {
-	err := mBatch.db.db.Write(mBatch.batch, &opt.WriteOptions{Sync: false})
+	err := mBatch.db.db.Write(mBatch.batch, &optPkg.WriteOptions{Sync: false})
 	if err != nil {
 		panic(err)
 	}
 }
 
 // Implements Batch.
 func (mBatch *goLevelDBBatch) WriteSync() {
-	err := mBatch.db.db.Write(mBatch.batch, &opt.WriteOptions{Sync: true})
+	err := mBatch.db.db.Write(mBatch.batch, &optPkg.WriteOptions{Sync: true})
 	if err != nil {
 		panic(err)
 	}
diff --git a/libs/db/mem_db.go b/libs/db/mem_db.go
@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	registerDBCreator(MemDBBackend, func(name string, dir string) (DB, error) {
+	registerDBCreator(MemDBBackend, func(name string, dir string, opt interface{}) (DB, error) {
 		return NewMemDB(), nil
 	}, false)
 }
diff --git a/node/node.go b/node/node.go
@@ -59,7 +59,7 @@ type DBProvider func(*DBContext) (dbm.DB, error)
 // specified in the ctx.Config.
 func DefaultDBProvider(ctx *DBContext) (dbm.DB, error) {
 	dbType := dbm.DBBackendType(ctx.Config.DBBackend)
-	return dbm.NewDB(ctx.ID, dbType, ctx.Config.DBDir()), nil
+	return dbm.NewDBWithOpt(ctx.ID, dbType, ctx.Config.DBDir(), ctx.Config.DBCache.ToGolevelDBOpt()), nil
 }
 
 // GenesisDocProvider returns a GenesisDoc.
diff --git a/p2p/pex/pex_reactor.go b/p2p/pex/pex_reactor.go
@@ -245,7 +245,8 @@ func (r *PEXReactor) Receive(chID byte, src Peer, msgBytes []byte) {
 		} else {
 			// Check we're not receiving requests too frequently.
 			if err := r.receiveRequest(src); err != nil {
-				r.Switch.StopPeerForError(src, err)
+				// If the peer send pexrequest too quick, just ignore it. No need to stop the peer
+				r.Logger.Error(err.Error())
 				return
 			}
 			r.SendAddrs(src, r.book.GetSelection())
diff --git a/state/store.go b/state/store.go
@@ -9,6 +9,14 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
+const (
+	// persist validators every valSetCheckpointInterval blocks to avoid
+	// LoadValidators taking too much time.
+	// https://github.com/tendermint/tendermint/pull/3438
+	// 100000 results in ~ 100ms to get 100 validators (see BenchmarkLoadValidators)
+	valSetCheckpointInterval = 100000
+)
+
 //------------------------------------------------------------------------
 
 const latestStateToKeep int64 = 1 << 20
@@ -207,25 +215,40 @@ func LoadValidators(db dbm.DB, height int64) (*types.ValidatorSet, error) {
 	if valInfo == nil {
 		return nil, ErrNoValSetForHeight{height}
 	}
-
 	if valInfo.ValidatorSet == nil {
-		valInfo2 := loadValidatorsInfo(db, valInfo.LastHeightChanged)
+		lastStoredHeight := lastStoredHeightFor(height, valInfo.LastHeightChanged)
+		valInfo2 := loadValidatorsInfo(db, lastStoredHeight)
 		if valInfo2 == nil {
-			panic(
-				fmt.Sprintf(
-					"Couldn't find validators at height %d as last changed from height %d",
-					valInfo.LastHeightChanged,
-					height,
-				),
-			)
+			// TODO (melekes): remove the below if condition in the 0.33 major
+			// release and just panic. Old chains might panic otherwise if they
+			// haven't saved validators at intermediate (%valSetCheckpointInterval)
+			// height yet.
+			valInfo2 = loadValidatorsInfo(db, valInfo.LastHeightChanged)
+			lastStoredHeight = valInfo.LastHeightChanged
+			if valInfo2 == nil {
+				panic(
+					fmt.Sprintf("Couldn't find validators at height %d (height %d was originally requested)",
+						lastStoredHeight,
+						height,
+					),
+				)
+			}
 		}
-		valInfo2.ValidatorSet.IncrementProposerPriority(int(height - valInfo.LastHeightChanged)) // mutate
+		valInfo2.ValidatorSet.IncrementProposerPriority(int(height - lastStoredHeight)) // mutate
 		valInfo = valInfo2
 	}
 
 	return valInfo.ValidatorSet, nil
 }
 
+func lastStoredHeightFor(height, lastHeightChanged int64) int64 {
+	checkpointHeight := height - height%valSetCheckpointInterval
+	if checkpointHeight > lastHeightChanged {
+		return checkpointHeight
+	}
+	return lastHeightChanged
+}
+
 // CONTRACT: Returned ValidatorsInfo can be mutated.
 func loadValidatorsInfo(db dbm.DB, height int64) *ValidatorsInfo {
 	buf := db.Get(calcValidatorsKey(height))
@@ -257,7 +280,7 @@ func saveValidatorsInfo(db dbm.DB, height, lastHeightChanged int64, valSet *type
 	valInfo := &ValidatorsInfo{
 		LastHeightChanged: lastHeightChanged,
 	}
-	if lastHeightChanged == height {
+	if height == lastHeightChanged || height%valSetCheckpointInterval == 0 {
 		valInfo.ValidatorSet = valSet
 	}
 	db.Set(calcValidatorsKey(height), valInfo.Bytes())
diff --git a/state/store_test.go b/state/store_test.go

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ import (`
`11`	`11`	`)`
`12`	`12`
`13`	`13`	`func init() {`
`14`		`- dbCreator := func(name string, dir string) (DB, error) {`
	`14`	`+ dbCreator := func(name string, dir string, opt interface{}) (DB, error) {`
`15`	`15`	`return NewCLevelDB(name, dir)`
`16`	`16`	`}`
`17`	`17`	`registerDBCreator(LevelDBBackend, dbCreator, true)`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ const (`
`20`	`20`	`)`
`21`	`21`
`22`	`22`	`func init() {`
`23`		`- registerDBCreator(FSDBBackend, func(name string, dir string) (DB, error) {`
	`23`	`+ registerDBCreator(FSDBBackend, func(name string, dir string, opt interface{}) (DB, error) {`
`24`	`24`	`dbPath := filepath.Join(dir, name+".db")`
`25`	`25`	`return NewFSDB(dbPath), nil`
`26`	`26`	`}, false)`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ import (`
`7`	`7`	`)`
`8`	`8`
`9`	`9`	`func init() {`
`10`		`- registerDBCreator(MemDBBackend, func(name string, dir string) (DB, error) {`
	`10`	`+ registerDBCreator(MemDBBackend, func(name string, dir string, opt interface{}) (DB, error) {`
`11`	`11`	`return NewMemDB(), nil`
`12`	`12`	`}, false)`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ type DBProvider func(*DBContext) (dbm.DB, error)`
`59`	`59`	`// specified in the ctx.Config.`
`60`	`60`	`func DefaultDBProvider(ctx *DBContext) (dbm.DB, error) {`
`61`	`61`	`dbType := dbm.DBBackendType(ctx.Config.DBBackend)`
`62`		`- return dbm.NewDB(ctx.ID, dbType, ctx.Config.DBDir()), nil`
	`62`	`+ return dbm.NewDBWithOpt(ctx.ID, dbType, ctx.Config.DBDir(), ctx.Config.DBCache.ToGolevelDBOpt()), nil`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`// GenesisDocProvider returns a GenesisDoc.`