From 1069ffc6aafa54ace10632c54bdc0c9872fb7ee9 Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Wed, 17 Aug 2022 11:19:20 -0400 Subject: [PATCH] config: backport the rename of fastsync to blocksync (#9259) This is largely a cherry pick of #6755 with some additional fixups added where detected. This change moves the blockchain package to a package called blocksync. Additionally, it renames the relevant uses of the term `fastsync` to `blocksync`. closes: #9227 #### PR checklist - [ ] Tests written/updated, or no tests needed - [x] `CHANGELOG_PENDING.md` updated, or no changelog entry needed - [x] Updated relevant documentation (`docs/`) and code comments, or no documentation updates needed --- CHANGELOG_PENDING.md | 2 + {blockchain => blocksync}/msgs.go | 4 +- {blockchain => blocksync}/msgs_test.go | 13 +-- {blockchain => blocksync}/pool.go | 4 +- {blockchain => blocksync}/pool_test.go | 2 +- {blockchain => blocksync}/reactor.go | 42 +++++----- {blockchain => blocksync}/reactor_test.go | 2 +- cmd/tendermint/commands/root.go | 5 ++ cmd/tendermint/commands/run_node.go | 2 +- config/config.go | 76 ++++++++++------- config/config_test.go | 4 +- config/toml.go | 16 ++-- consensus/metrics.gen.go | 8 +- consensus/metrics.go | 4 +- consensus/reactor.go | 14 ++-- docs/tendermint-core/README.md | 2 +- .../{fast-sync.md => block-sync.md} | 31 +++---- docs/tendermint-core/configuration.md | 16 ++-- docs/tendermint-core/metrics.md | 2 +- docs/tendermint-core/state-sync.md | 2 +- node/node.go | 58 ++++++------- .../{blockchain => blocksync}/types.pb.go | 81 +++++++++---------- .../{blockchain => blocksync}/types.proto | 4 +- spec/abci/abci.md | 2 +- spec/p2p/messages/block-sync.md | 2 +- test/e2e/README.md | 2 +- test/e2e/generator/generate.go | 4 +- test/e2e/networks/ci.toml | 8 +- test/e2e/pkg/manifest.go | 5 +- test/e2e/pkg/testnet.go | 9 ++- test/e2e/runner/setup.go | 6 +- 31 files changed, 235 insertions(+), 197 deletions(-) rename {blockchain => blocksync}/msgs.go (99%) rename {blockchain => blocksync}/msgs_test.go (88%) rename {blockchain => blocksync}/pool.go (99%) rename {blockchain => blocksync}/pool_test.go (99%) rename {blockchain => blocksync}/reactor.go (93%) rename {blockchain => blocksync}/reactor_test.go (99%) rename docs/tendermint-core/{fast-sync.md => block-sync.md} (63%) rename proto/tendermint/{blockchain => blocksync}/types.pb.go (90%) rename proto/tendermint/{blockchain => blocksync}/types.proto (94%) diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md index 6ddb8f795..2f2eb506b 100644 --- a/CHANGELOG_PENDING.md +++ b/CHANGELOG_PENDING.md @@ -10,6 +10,8 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi - CLI/RPC/Config + - [config] \#9259 Rename the fastsync section and the fast_sync key blocksync and block_sync respectively + - Apps - [abci/counter] \#6684 Delete counter example app diff --git a/blockchain/msgs.go b/blocksync/msgs.go similarity index 99% rename from blockchain/msgs.go rename to blocksync/msgs.go index 35868830b..081cbe4f8 100644 --- a/blockchain/msgs.go +++ b/blocksync/msgs.go @@ -1,4 +1,4 @@ -package blockchain +package blocksync import ( "errors" @@ -6,7 +6,7 @@ import ( "github.com/gogo/protobuf/proto" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/types" ) diff --git a/blockchain/msgs_test.go b/blocksync/msgs_test.go similarity index 88% rename from blockchain/msgs_test.go rename to blocksync/msgs_test.go index df8efca14..b27376b14 100644 --- a/blockchain/msgs_test.go +++ b/blocksync/msgs_test.go @@ -1,4 +1,4 @@ -package blockchain +package blocksync_test import ( "encoding/hex" @@ -9,7 +9,8 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + "github.com/tendermint/tendermint/blocksync" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/types" ) @@ -28,7 +29,7 @@ func TestBcBlockRequestMessageValidateBasic(t *testing.T) { tc := tc t.Run(tc.testName, func(t *testing.T) { request := bcproto.BlockRequest{Height: tc.requestHeight} - assert.Equal(t, tc.expectErr, ValidateMsg(&request) != nil, "Validate Basic had an unexpected result") + assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&request) != nil, "Validate Basic had an unexpected result") }) } } @@ -48,14 +49,14 @@ func TestBcNoBlockResponseMessageValidateBasic(t *testing.T) { tc := tc t.Run(tc.testName, func(t *testing.T) { nonResponse := bcproto.NoBlockResponse{Height: tc.nonResponseHeight} - assert.Equal(t, tc.expectErr, ValidateMsg(&nonResponse) != nil, "Validate Basic had an unexpected result") + assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&nonResponse) != nil, "Validate Basic had an unexpected result") }) } } func TestBcStatusRequestMessageValidateBasic(t *testing.T) { request := bcproto.StatusRequest{} - assert.NoError(t, ValidateMsg(&request)) + assert.NoError(t, blocksync.ValidateMsg(&request)) } func TestBcStatusResponseMessageValidateBasic(t *testing.T) { @@ -73,7 +74,7 @@ func TestBcStatusResponseMessageValidateBasic(t *testing.T) { tc := tc t.Run(tc.testName, func(t *testing.T) { response := bcproto.StatusResponse{Height: tc.responseHeight} - assert.Equal(t, tc.expectErr, ValidateMsg(&response) != nil, "Validate Basic had an unexpected result") + assert.Equal(t, tc.expectErr, blocksync.ValidateMsg(&response) != nil, "Validate Basic had an unexpected result") }) } } diff --git a/blockchain/pool.go b/blocksync/pool.go similarity index 99% rename from blockchain/pool.go rename to blocksync/pool.go index ceab887ad..99dcb79e2 100644 --- a/blockchain/pool.go +++ b/blocksync/pool.go @@ -1,4 +1,4 @@ -package blockchain +package blocksync import ( "errors" @@ -58,7 +58,7 @@ var peerTimeout = 15 * time.Second // not const so we can override with tests are not at peer limits, we can probably switch to consensus reactor */ -// BlockPool keeps track of the fast sync peers, block requests and block responses. +// BlockPool keeps track of the block sync peers, block requests and block responses. type BlockPool struct { service.BaseService startTime time.Time diff --git a/blockchain/pool_test.go b/blocksync/pool_test.go similarity index 99% rename from blockchain/pool_test.go rename to blocksync/pool_test.go index c67da0afd..9fcc9dde4 100644 --- a/blockchain/pool_test.go +++ b/blocksync/pool_test.go @@ -1,4 +1,4 @@ -package blockchain +package blocksync import ( "fmt" diff --git a/blockchain/reactor.go b/blocksync/reactor.go similarity index 93% rename from blockchain/reactor.go rename to blocksync/reactor.go index 06a77de4d..1f867ca98 100644 --- a/blockchain/reactor.go +++ b/blocksync/reactor.go @@ -1,4 +1,4 @@ -package blockchain +package blocksync import ( "fmt" @@ -7,15 +7,15 @@ import ( "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/p2p" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" sm "github.com/tendermint/tendermint/state" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" ) const ( - // BlockchainChannel is a channel for blocks and status updates (`BlockStore` height) - BlockchainChannel = byte(0x40) + // BlocksyncChannel is a channel for blocks and status updates (`BlockStore` height) + BlocksyncChannel = byte(0x40) trySyncIntervalMS = 10 @@ -30,7 +30,7 @@ const ( ) type consensusReactor interface { - // for when we switch from blockchain reactor and fast sync to + // for when we switch from blockchain reactor and block sync to // the consensus machine SwitchToConsensus(state sm.State, skipWAL bool) } @@ -54,7 +54,7 @@ type Reactor struct { blockExec *sm.BlockExecutor store *store.BlockStore pool *BlockPool - fastSync bool + blockSync bool requestsCh <-chan BlockRequest errorsCh <-chan peerError @@ -62,7 +62,7 @@ type Reactor struct { // NewReactor returns new reactor instance. func NewReactor(state sm.State, blockExec *sm.BlockExecutor, store *store.BlockStore, - fastSync bool) *Reactor { + blockSync bool) *Reactor { if state.LastBlockHeight != store.Height() { panic(fmt.Sprintf("state (%v) and store (%v) height mismatch", state.LastBlockHeight, @@ -85,7 +85,7 @@ func NewReactor(state sm.State, blockExec *sm.BlockExecutor, store *store.BlockS blockExec: blockExec, store: store, pool: pool, - fastSync: fastSync, + blockSync: blockSync, requestsCh: requestsCh, errorsCh: errorsCh, } @@ -101,7 +101,7 @@ func (bcR *Reactor) SetLogger(l log.Logger) { // OnStart implements service.Service. func (bcR *Reactor) OnStart() error { - if bcR.fastSync { + if bcR.blockSync { err := bcR.pool.Start() if err != nil { return err @@ -111,9 +111,9 @@ func (bcR *Reactor) OnStart() error { return nil } -// SwitchToFastSync is called by the state sync reactor when switching to fast sync. -func (bcR *Reactor) SwitchToFastSync(state sm.State) error { - bcR.fastSync = true +// SwitchToBlockSync is called by the state sync reactor when switching to block sync. +func (bcR *Reactor) SwitchToBlockSync(state sm.State) error { + bcR.blockSync = true bcR.initialState = state bcR.pool.height = state.LastBlockHeight + 1 @@ -127,7 +127,7 @@ func (bcR *Reactor) SwitchToFastSync(state sm.State) error { // OnStop implements service.Service. func (bcR *Reactor) OnStop() { - if bcR.fastSync { + if bcR.blockSync { if err := bcR.pool.Stop(); err != nil { bcR.Logger.Error("Error stopping pool", "err", err) } @@ -138,7 +138,7 @@ func (bcR *Reactor) OnStop() { func (bcR *Reactor) GetChannels() []*p2p.ChannelDescriptor { return []*p2p.ChannelDescriptor{ { - ID: BlockchainChannel, + ID: BlocksyncChannel, Priority: 5, SendQueueCapacity: 1000, RecvBufferCapacity: 50 * 4096, @@ -157,7 +157,7 @@ func (bcR *Reactor) AddPeer(peer p2p.Peer) { return } - peer.Send(BlockchainChannel, msgBytes) + peer.Send(BlocksyncChannel, msgBytes) // it's OK if send fails. will try later in poolRoutine // peer is added to the pool once we receive the first @@ -188,7 +188,7 @@ func (bcR *Reactor) respondToPeer(msg *bcproto.BlockRequest, return false } - return src.TrySend(BlockchainChannel, msgBytes) + return src.TrySend(BlocksyncChannel, msgBytes) } bcR.Logger.Info("Peer asking for a block we don't have", "src", src, "height", msg.Height) @@ -199,7 +199,7 @@ func (bcR *Reactor) respondToPeer(msg *bcproto.BlockRequest, return false } - return src.TrySend(BlockchainChannel, msgBytes) + return src.TrySend(BlocksyncChannel, msgBytes) } // Receive implements Reactor by handling 4 types of messages (look below). @@ -239,7 +239,7 @@ func (bcR *Reactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) { bcR.Logger.Error("could not convert msg to protobut", "err", err) return } - src.TrySend(BlockchainChannel, msgBytes) + src.TrySend(BlocksyncChannel, msgBytes) case *bcproto.StatusResponse: // Got a peer status. Unverified. bcR.pool.SetPeerRange(src.ID(), msg.Base, msg.Height) @@ -291,7 +291,7 @@ func (bcR *Reactor) poolRoutine(stateSynced bool) { continue } - queued := peer.TrySend(BlockchainChannel, msgBytes) + queued := peer.TrySend(BlocksyncChannel, msgBytes) if !queued { bcR.Logger.Debug("Send queue is full, drop block request", "peer", peer.ID(), "height", request.Height) } @@ -409,7 +409,7 @@ FOR_LOOP: if blocksSynced%100 == 0 { lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds()) - bcR.Logger.Info("Fast Sync Rate", "height", bcR.pool.height, + bcR.Logger.Info("Block Sync Rate", "height", bcR.pool.height, "max_peer_height", bcR.pool.MaxPeerHeight(), "blocks/s", lastRate) lastHundred = time.Now() } @@ -430,7 +430,7 @@ func (bcR *Reactor) BroadcastStatusRequest() error { return fmt.Errorf("could not convert msg to proto: %w", err) } - bcR.Switch.Broadcast(BlockchainChannel, bm) + bcR.Switch.Broadcast(BlocksyncChannel, bm) return nil } diff --git a/blockchain/reactor_test.go b/blocksync/reactor_test.go similarity index 99% rename from blockchain/reactor_test.go rename to blocksync/reactor_test.go index db4cbead2..18c8c3059 100644 --- a/blockchain/reactor_test.go +++ b/blocksync/reactor_test.go @@ -1,4 +1,4 @@ -package blockchain +package blocksync import ( "fmt" diff --git a/cmd/tendermint/commands/root.go b/cmd/tendermint/commands/root.go index 46c9ac7c7..16ea8a391 100644 --- a/cmd/tendermint/commands/root.go +++ b/cmd/tendermint/commands/root.go @@ -53,6 +53,11 @@ func ParseConfig(cmd *cobra.Command) (*cfg.Config, error) { if err := conf.ValidateBasic(); err != nil { return nil, fmt.Errorf("error in config file: %v", err) } + if warnings := conf.CheckDeprecated(); len(warnings) > 0 { + for _, warning := range warnings { + logger.Info("deprecated usage found in configuration file", "usage", warning) + } + } return conf, nil } diff --git a/cmd/tendermint/commands/run_node.go b/cmd/tendermint/commands/run_node.go index d78eab2c8..ac2984111 100644 --- a/cmd/tendermint/commands/run_node.go +++ b/cmd/tendermint/commands/run_node.go @@ -31,7 +31,7 @@ func AddNodeFlags(cmd *cobra.Command) { "socket address to listen on for connections from external priv_validator process") // node flags - cmd.Flags().Bool("fast_sync", config.FastSyncMode, "fast blockchain syncing") + cmd.Flags().Bool("block_sync", config.BlockSyncMode, "sync the block chain using the blocksync algorithm") cmd.Flags().BytesHexVar( &genesisHash, "genesis_hash", diff --git a/config/config.go b/config/config.go index 9c8c3c236..6cb12835d 100644 --- a/config/config.go +++ b/config/config.go @@ -68,14 +68,17 @@ type Config struct { BaseConfig `mapstructure:",squash"` // Options for services - RPC *RPCConfig `mapstructure:"rpc"` - P2P *P2PConfig `mapstructure:"p2p"` - Mempool *MempoolConfig `mapstructure:"mempool"` - StateSync *StateSyncConfig `mapstructure:"statesync"` - FastSync *FastSyncConfig `mapstructure:"fastsync"` - Consensus *ConsensusConfig `mapstructure:"consensus"` - TxIndex *TxIndexConfig `mapstructure:"tx_index"` - Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"` + RPC *RPCConfig `mapstructure:"rpc"` + P2P *P2PConfig `mapstructure:"p2p"` + Mempool *MempoolConfig `mapstructure:"mempool"` + StateSync *StateSyncConfig `mapstructure:"statesync"` + BlockSync *BlockSyncConfig `mapstructure:"blocksync"` + //TODO(williambanfield): remove this field once v0.37 is released. + // https://github.com/tendermint/tendermint/issues/9279 + DeprecatedFastSyncConfig map[interface{}]interface{} `mapstructure:"fastsync"` + Consensus *ConsensusConfig `mapstructure:"consensus"` + TxIndex *TxIndexConfig `mapstructure:"tx_index"` + Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"` } // DefaultConfig returns a default configuration for a Tendermint node @@ -86,7 +89,7 @@ func DefaultConfig() *Config { P2P: DefaultP2PConfig(), Mempool: DefaultMempoolConfig(), StateSync: DefaultStateSyncConfig(), - FastSync: DefaultFastSyncConfig(), + BlockSync: DefaultBlockSyncConfig(), Consensus: DefaultConsensusConfig(), TxIndex: DefaultTxIndexConfig(), Instrumentation: DefaultInstrumentationConfig(), @@ -101,7 +104,7 @@ func TestConfig() *Config { P2P: TestP2PConfig(), Mempool: TestMempoolConfig(), StateSync: TestStateSyncConfig(), - FastSync: TestFastSyncConfig(), + BlockSync: TestBlockSyncConfig(), Consensus: TestConsensusConfig(), TxIndex: TestTxIndexConfig(), Instrumentation: TestInstrumentationConfig(), @@ -136,8 +139,8 @@ func (cfg *Config) ValidateBasic() error { if err := cfg.StateSync.ValidateBasic(); err != nil { return fmt.Errorf("error in [statesync] section: %w", err) } - if err := cfg.FastSync.ValidateBasic(); err != nil { - return fmt.Errorf("error in [fastsync] section: %w", err) + if err := cfg.BlockSync.ValidateBasic(); err != nil { + return fmt.Errorf("error in [blocksync] section: %w", err) } if err := cfg.Consensus.ValidateBasic(); err != nil { return fmt.Errorf("error in [consensus] section: %w", err) @@ -148,6 +151,17 @@ func (cfg *Config) ValidateBasic() error { return nil } +func (cfg *Config) CheckDeprecated() []string { + var warnings []string + if cfg.DeprecatedFastSyncConfig != nil { + warnings = append(warnings, "[fastsync] table detected. This section has been renamed to [blocksync]. The values in this deprecated section will be disregarded.") + } + if cfg.BaseConfig.DeprecatedFastSyncMode != nil { + warnings = append(warnings, "fast_sync key detected. This key has been renamed to block_sync. The value of this deprecated key will be disregarded.") + } + return warnings +} + //----------------------------------------------------------------------------- // BaseConfig @@ -167,10 +181,14 @@ type BaseConfig struct { //nolint: maligned // A custom human readable name for this node Moniker string `mapstructure:"moniker"` - // If this node is many blocks behind the tip of the chain, FastSync + // If this node is many blocks behind the tip of the chain, Blocksync // allows them to catchup quickly by downloading blocks in parallel // and verifying their commits - FastSyncMode bool `mapstructure:"fast_sync"` + BlockSyncMode bool `mapstructure:"block_sync"` + + //TODO(williambanfield): remove this field once v0.37 is released. + // https://github.com/tendermint/tendermint/issues/9279 + DeprecatedFastSyncMode interface{} `mapstructure:"fast_sync"` // Database backend: goleveldb | cleveldb | boltdb | rocksdb // * goleveldb (github.com/syndtr/goleveldb - most popular implementation) @@ -238,7 +256,7 @@ func DefaultBaseConfig() BaseConfig { ABCI: "socket", LogLevel: DefaultLogLevel, LogFormat: LogFormatPlain, - FastSyncMode: true, + BlockSyncMode: true, FilterPeers: false, DBBackend: "goleveldb", DBPath: "data", @@ -250,7 +268,7 @@ func TestBaseConfig() BaseConfig { cfg := DefaultBaseConfig() cfg.chainID = "tendermint_test" cfg.ProxyApp = "kvstore" - cfg.FastSyncMode = false + cfg.BlockSyncMode = false cfg.DBBackend = "memdb" return cfg } @@ -817,7 +835,7 @@ func DefaultStateSyncConfig() *StateSyncConfig { } } -// TestFastSyncConfig returns a default configuration for the state sync service +// TestStateSyncConfig returns a default configuration for the state sync service func TestStateSyncConfig() *StateSyncConfig { return DefaultStateSyncConfig() } @@ -873,34 +891,34 @@ func (cfg *StateSyncConfig) ValidateBasic() error { } //----------------------------------------------------------------------------- -// FastSyncConfig +// BlockSyncConfig -// FastSyncConfig defines the configuration for the Tendermint fast sync service -type FastSyncConfig struct { +// BlockSyncConfig (formerly known as FastSync) defines the configuration for the Tendermint block sync service +type BlockSyncConfig struct { Version string `mapstructure:"version"` } -// DefaultFastSyncConfig returns a default configuration for the fast sync service -func DefaultFastSyncConfig() *FastSyncConfig { - return &FastSyncConfig{ +// DefaultBlockSyncConfig returns a default configuration for the block sync service +func DefaultBlockSyncConfig() *BlockSyncConfig { + return &BlockSyncConfig{ Version: "v0", } } -// TestFastSyncConfig returns a default configuration for the fast sync. -func TestFastSyncConfig() *FastSyncConfig { - return DefaultFastSyncConfig() +// TestBlockSyncConfig returns a default configuration for the block sync. +func TestBlockSyncConfig() *BlockSyncConfig { + return DefaultBlockSyncConfig() } // ValidateBasic performs basic validation. -func (cfg *FastSyncConfig) ValidateBasic() error { +func (cfg *BlockSyncConfig) ValidateBasic() error { switch cfg.Version { case "v0": return nil case "v1", "v2": - return fmt.Errorf("fast sync version %s has been deprecated. Please use v0 instead", cfg.Version) + return fmt.Errorf("blocksync version %s has been deprecated. Please use v0 instead", cfg.Version) default: - return fmt.Errorf("unknown fastsync version %s", cfg.Version) + return fmt.Errorf("unknown blocksync version %s", cfg.Version) } } diff --git a/config/config_test.go b/config/config_test.go index cdcddf427..2446f08e6 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -128,8 +128,8 @@ func TestStateSyncConfigValidateBasic(t *testing.T) { require.NoError(t, cfg.ValidateBasic()) } -func TestFastSyncConfigValidateBasic(t *testing.T) { - cfg := TestFastSyncConfig() +func TestBlockSyncConfigValidateBasic(t *testing.T) { + cfg := TestBlockSyncConfig() assert.NoError(t, cfg.ValidateBasic()) // tamper with version diff --git a/config/toml.go b/config/toml.go index a0112351d..d8ef7c86d 100644 --- a/config/toml.go +++ b/config/toml.go @@ -87,10 +87,10 @@ proxy_app = "{{ .BaseConfig.ProxyApp }}" # A custom human readable name for this node moniker = "{{ .BaseConfig.Moniker }}" -# If this node is many blocks behind the tip of the chain, FastSync +# If this node is many blocks behind the tip of the chain, BlockSync # allows them to catchup quickly by downloading blocks in parallel # and verifying their commits -fast_sync = {{ .BaseConfig.FastSyncMode }} +block_sync = {{ .BaseConfig.BlockSyncMode }} # Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb # * goleveldb (github.com/syndtr/goleveldb - most popular implementation) @@ -429,17 +429,17 @@ chunk_request_timeout = "{{ .StateSync.ChunkRequestTimeout }}" chunk_fetchers = "{{ .StateSync.ChunkFetchers }}" ####################################################### -### Fast Sync Configuration Connections ### +### Block Sync Configuration Options ### ####################################################### -[fastsync] +[blocksync] -# Fast Sync version to use: +# Block Sync version to use: # -# In v0.37, v1 and v2 of the fast sync protocol were deprecated. +# In v0.37, v1 and v2 of the block sync protocols were deprecated. # Please use v0 instead. # -# 1) "v0" - the default fast sync implementation -version = "{{ .FastSync.Version }}" +# 1) "v0" - the default block sync implementation +version = "{{ .BlockSync.Version }}" ####################################################### ### Consensus Configuration Options ### diff --git a/consensus/metrics.gen.go b/consensus/metrics.gen.go index 70be488ef..e627dee57 100644 --- a/consensus/metrics.gen.go +++ b/consensus/metrics.gen.go @@ -118,11 +118,11 @@ func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics { Name: "latest_block_height", Help: "The latest block height.", }, labels).With(labelsAndValues...), - FastSyncing: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{ + BlockSyncing: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{ Namespace: namespace, Subsystem: MetricsSubsystem, - Name: "fast_syncing", - Help: "Whether or not a node is fast syncing. 1 if yes, 0 if no.", + Name: "block_syncing", + Help: "Whether or not a node is block syncing. 1 if yes, 0 if no.", }, labels).With(labelsAndValues...), StateSyncing: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{ Namespace: namespace, @@ -184,7 +184,7 @@ func NopMetrics() *Metrics { BlockSizeBytes: discard.NewGauge(), TotalTxs: discard.NewGauge(), CommittedHeight: discard.NewGauge(), - FastSyncing: discard.NewGauge(), + BlockSyncing: discard.NewGauge(), StateSyncing: discard.NewGauge(), BlockParts: discard.NewCounter(), StepDurationSeconds: discard.NewHistogram(), diff --git a/consensus/metrics.go b/consensus/metrics.go index de0da45de..2a82d732f 100644 --- a/consensus/metrics.go +++ b/consensus/metrics.go @@ -59,8 +59,8 @@ type Metrics struct { TotalTxs metrics.Gauge // The latest block height. CommittedHeight metrics.Gauge `metrics_name:"latest_block_height"` - // Whether or not a node is fast syncing. 1 if yes, 0 if no. - FastSyncing metrics.Gauge + // Whether or not a node is block syncing. 1 if yes, 0 if no. + BlockSyncing metrics.Gauge // Whether or not a node is state syncing. 1 if yes, 0 if no. StateSyncing metrics.Gauge diff --git a/consensus/reactor.go b/consensus/reactor.go index d6b22786b..c86f21c98 100644 --- a/consensus/reactor.go +++ b/consensus/reactor.go @@ -72,7 +72,7 @@ func NewReactor(consensusState *State, waitSync bool, options ...ReactorOption) } // OnStart implements BaseService by subscribing to events, which later will be -// broadcasted to other peers and starting state if we're not in fast sync. +// broadcasted to other peers and starting state if we're not in block sync. func (conR *Reactor) OnStart() error { conR.Logger.Info("Reactor ", "waitSync", conR.WaitSync()) @@ -104,8 +104,8 @@ func (conR *Reactor) OnStop() { } } -// SwitchToConsensus switches from fast_sync mode to consensus mode. -// It resets the state, turns off fast_sync, and starts the consensus state-machine +// SwitchToConsensus switches from block_sync mode to consensus mode. +// It resets the state, turns off block_sync, and starts the consensus state-machine func (conR *Reactor) SwitchToConsensus(state sm.State, skipWAL bool) { conR.Logger.Info("SwitchToConsensus") @@ -121,7 +121,7 @@ func (conR *Reactor) SwitchToConsensus(state sm.State, skipWAL bool) { conR.mtx.Lock() conR.waitSync = false conR.mtx.Unlock() - conR.Metrics.FastSyncing.Set(0) + conR.Metrics.BlockSyncing.Set(0) conR.Metrics.StateSyncing.Set(0) if skipWAL { @@ -198,7 +198,7 @@ func (conR *Reactor) AddPeer(peer p2p.Peer) { go conR.queryMaj23Routine(peer, peerState) // Send our state to peer. - // If we're fast_syncing, broadcast a RoundStepMessage later upon SwitchToConsensus(). + // If we're block_syncing, broadcast a RoundStepMessage later upon SwitchToConsensus(). if !conR.WaitSync() { conR.sendNewRoundStepMessage(peer) } @@ -218,7 +218,7 @@ func (conR *Reactor) RemovePeer(peer p2p.Peer, reason interface{}) { } // Receive implements Reactor -// NOTE: We process these messages even when we're fast_syncing. +// NOTE: We process these messages even when we're block_syncing. // Messages affect either a peer state or the consensus state. // Peer state updates can happen in parallel, but processing of // proposals, block parts, and votes are ordered by the receiveRoutine @@ -386,7 +386,7 @@ func (conR *Reactor) SetEventBus(b *types.EventBus) { conR.conS.SetEventBus(b) } -// WaitSync returns whether the consensus reactor is waiting for state/fast sync. +// WaitSync returns whether the consensus reactor is waiting for state/block sync. func (conR *Reactor) WaitSync() bool { conR.mtx.RLock() defer conR.mtx.RUnlock() diff --git a/docs/tendermint-core/README.md b/docs/tendermint-core/README.md index fa94f3a1e..60f995204 100644 --- a/docs/tendermint-core/README.md +++ b/docs/tendermint-core/README.md @@ -17,7 +17,7 @@ This section dives into the internals of Tendermint the implementation. - [Subscribing to events](./subscription.md) - [Block Structure](./block-structure.md) - [RPC](./rpc.md) -- [Fast Sync](./fast-sync.md) +- [Block Sync](./block-sync.md) - [State Sync](./state-sync.md) - [Mempool](./mempool.md) - [Light Client](./light-client.md) diff --git a/docs/tendermint-core/fast-sync.md b/docs/tendermint-core/block-sync.md similarity index 63% rename from docs/tendermint-core/fast-sync.md rename to docs/tendermint-core/block-sync.md index 9bbeade38..4d55d52b8 100644 --- a/docs/tendermint-core/fast-sync.md +++ b/docs/tendermint-core/block-sync.md @@ -2,7 +2,8 @@ order: 10 --- -# Fast Sync +# Block Sync +*Formerly known as Fast Sync* In a proof of work blockchain, syncing with the chain is the same process as staying up-to-date with the consensus: download blocks, and @@ -14,35 +15,37 @@ scratch can take a very long time. It's much faster to just download blocks and check the merkle tree of validators than to run the real-time consensus gossip protocol. -## Using Fast Sync +## Using Block Sync -To support faster syncing, Tendermint offers a `fast-sync` mode, which +To support faster syncing, Tendermint offers a `block-sync` mode, which is enabled by default, and can be toggled in the `config.toml` or via -`--fast_sync=false`. +`--block_sync=false`. In this mode, the Tendermint daemon will sync hundreds of times faster than if it used the real-time consensus process. Once caught up, the -daemon will switch out of fast sync and into the normal consensus mode. +daemon will switch out of Block Sync and into the normal consensus mode. After running for some time, the node is considered `caught up` if it has at least one peer and it's height is at least as high as the max reported peer height. See [the IsCaughtUp method](https://github.com/tendermint/tendermint/blob/b467515719e686e4678e6da4e102f32a491b85a0/blockchain/pool.go#L128). -Note: There are three versions of fast sync. We recommend using v0 as v1 and v2 are still in beta. - If you would like to use a different version you can do so by changing the version in the `config.toml`: +Note: While there have historically been multiple versions of blocksync, v0, v1, and v2, all versions +other than v0 have been deprecated in favor of the simplest and most well understood algorithm. ```toml ####################################################### -### Fast Sync Configuration Connections ### +### Block Sync Configuration Options ### ####################################################### -[fastsync] +[blocksync] -# Fast Sync version to use: -# 1) "v0" (default) - the legacy fast sync implementation -# 2) "v1" - refactor of v0 version for better testability -# 2) "v2" - complete redesign of v0, optimized for testability & readability +# Block Sync version to use: +# +# In v0.37, v1 and v2 of the block sync protocols were deprecated. +# Please use v0 instead. +# +# 1) "v0" - the default block sync implementation version = "v0" ``` -If we're lagging sufficiently, we should go back to fast syncing, but +If we're lagging sufficiently, we should go back to block syncing, but this is an [open issue](https://github.com/tendermint/tendermint/issues/129). diff --git a/docs/tendermint-core/configuration.md b/docs/tendermint-core/configuration.md index 120716bfd..3925b21c8 100644 --- a/docs/tendermint-core/configuration.md +++ b/docs/tendermint-core/configuration.md @@ -36,10 +36,10 @@ proxy_app = "tcp://127.0.0.1:26658" # A custom human readable name for this node moniker = "anonymous" -# If this node is many blocks behind the tip of the chain, FastSync +# If this node is many blocks behind the tip of the chain, BlockSync # allows them to catchup quickly by downloading blocks in parallel # and verifying their commits -fast_sync = true +block_sync = true # Database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb # * goleveldb (github.com/syndtr/goleveldb - most popular implementation) @@ -319,16 +319,16 @@ trust_period = "0s" temp_dir = "" ####################################################### -### Fast Sync Configuration Connections ### +### Block Sync Configuration Options ### ####################################################### -[fastsync] +[blocksync] -# Fast Sync version to use: -# -# In v0.37, the v1 and v2 fast sync protocols were deprecated. +# Block Sync version to use: +# +# In v0.37, v1 and v2 of the block sync protocols were deprecated. # Please use v0 instead. # -# 1) "v0" (default) - the legacy fast sync implementation +# 1) "v0" - the default block sync implementation version = "v0" ####################################################### diff --git a/docs/tendermint-core/metrics.md b/docs/tendermint-core/metrics.md index b0f7033ac..8fb0353a0 100644 --- a/docs/tendermint-core/metrics.md +++ b/docs/tendermint-core/metrics.md @@ -37,7 +37,7 @@ The following metrics are available: | consensus_total_txs | Gauge | | Total number of transactions committed | | consensus_block_parts | counter | peer_id | number of blockparts transmitted by peer | | consensus_latest_block_height | gauge | | /status sync_info number | -| consensus_fast_syncing | gauge | | either 0 (not fast syncing) or 1 (syncing) | +| consensus_block_syncing | gauge | | either 0 (not block syncing) or 1 (syncing) | | consensus_state_syncing | gauge | | either 0 (not state syncing) or 1 (syncing) | | consensus_block_size_bytes | Gauge | | Block size in bytes | | consensus_step_duration | Histogram | step | Histogram of durations for each step in the consensus protocol | diff --git a/docs/tendermint-core/state-sync.md b/docs/tendermint-core/state-sync.md index a6e314fe5..8400a6ef9 100644 --- a/docs/tendermint-core/state-sync.md +++ b/docs/tendermint-core/state-sync.md @@ -4,7 +4,7 @@ order: 11 # State Sync -With fast sync a node is downloading all of the data of an application from genesis and verifying it. +With block sync a node is downloading all of the data of an application from genesis and verifying it. With state sync your node will download data related to the head or near the head of the chain and verify the data. This leads to drastically shorter times for joining a network. diff --git a/node/node.go b/node/node.go index 51fe490d8..36c9acd67 100644 --- a/node/node.go +++ b/node/node.go @@ -16,7 +16,7 @@ import ( dbm "github.com/tendermint/tm-db" abci "github.com/tendermint/tendermint/abci/types" - bc "github.com/tendermint/tendermint/blockchain" + bc "github.com/tendermint/tendermint/blocksync" cfg "github.com/tendermint/tendermint/config" cs "github.com/tendermint/tendermint/consensus" "github.com/tendermint/tendermint/crypto" @@ -133,10 +133,10 @@ func DefaultMetricsProvider(config *cfg.InstrumentationConfig) MetricsProvider { // Option sets a parameter for the node. type Option func(*Node) -// Temporary interface for switching to fast sync, we should get rid of v0 and v1 reactors. +// Temporary interface for switching to block sync, we should get rid of v0 and v1 reactors. // See: https://github.com/tendermint/tendermint/issues/4595 -type fastSyncReactor interface { - SwitchToFastSync(sm.State) error +type blockSyncReactor interface { + SwitchToBlockSync(sm.State) error } // CustomReactors allows you to add custom reactors (name -> p2p.Reactor) to @@ -212,7 +212,7 @@ type Node struct { eventBus *types.EventBus // pub/sub for services stateStore sm.Store blockStore *store.BlockStore // store the blockchain to disk - bcReactor p2p.Reactor // for fast-syncing + bcReactor p2p.Reactor // for block-syncing mempoolReactor p2p.Reactor // for gossipping transactions mempool mempl.Mempool stateSync bool // whether the node should state sync on startup @@ -443,16 +443,16 @@ func createBlockchainReactor(config *cfg.Config, state sm.State, blockExec *sm.BlockExecutor, blockStore *store.BlockStore, - fastSync bool, + blockSync bool, logger log.Logger) (bcReactor p2p.Reactor, err error) { - switch config.FastSync.Version { + switch config.BlockSync.Version { case "v0": - bcReactor = bc.NewReactor(state.Copy(), blockExec, blockStore, fastSync) + bcReactor = bc.NewReactor(state.Copy(), blockExec, blockStore, blockSync) case "v1", "v2": - return nil, fmt.Errorf("fast sync version %s has been deprecated. Please use v0", config.FastSync.Version) + return nil, fmt.Errorf("block sync version %s has been deprecated. Please use v0", config.BlockSync.Version) default: - return nil, fmt.Errorf("unknown fastsync version %s", config.FastSync.Version) + return nil, fmt.Errorf("unknown fastsync version %s", config.BlockSync.Version) } bcReactor.SetLogger(logger.With("module", "blockchain")) @@ -642,9 +642,9 @@ func createPEXReactorAndAddToSwitch(addrBook pex.AddrBook, config *cfg.Config, return pexReactor } -// startStateSync starts an asynchronous state sync process, then switches to fast sync mode. -func startStateSync(ssR *statesync.Reactor, bcR fastSyncReactor, conR *cs.Reactor, - stateProvider statesync.StateProvider, config *cfg.StateSyncConfig, fastSync bool, +// startStateSync starts an asynchronous state sync process, then switches to block sync mode. +func startStateSync(ssR *statesync.Reactor, bcR blockSyncReactor, conR *cs.Reactor, + stateProvider statesync.StateProvider, config *cfg.StateSyncConfig, blockSync bool, stateStore sm.Store, blockStore *store.BlockStore, state sm.State) error { ssR.Logger.Info("Starting state sync") @@ -682,13 +682,13 @@ func startStateSync(ssR *statesync.Reactor, bcR fastSyncReactor, conR *cs.Reacto return } - if fastSync { + if blockSync { // FIXME Very ugly to have these metrics bleed through here. conR.Metrics.StateSyncing.Set(0) - conR.Metrics.FastSyncing.Set(1) - err = bcR.SwitchToFastSync(state) + conR.Metrics.BlockSyncing.Set(1) + err = bcR.SwitchToBlockSync(state) if err != nil { - ssR.Logger.Error("Failed to switch to fast sync", "err", err) + ssR.Logger.Error("Failed to switch to block sync", "err", err) return } } else { @@ -783,9 +783,9 @@ func NewNode(config *cfg.Config, } } - // Determine whether we should do fast sync. This must happen after the handshake, since the + // Determine whether we should do block sync. This must happen after the handshake, since the // app may modify the validator set, specifying ourself as the only validator. - fastSync := config.FastSyncMode && !onlyValidatorIsUs(state, pubKey) + blockSync := config.BlockSyncMode && !onlyValidatorIsUs(state, pubKey) logNodeStartupInfo(state, pubKey, logger, consensusLogger) @@ -808,26 +808,26 @@ func NewNode(config *cfg.Config, sm.BlockExecutorWithMetrics(smMetrics), ) - // Make BlockchainReactor. Don't start fast sync if we're doing a state sync first. - bcReactor, err := createBlockchainReactor(config, state, blockExec, blockStore, fastSync && !stateSync, logger) + // Make BlockchainReactor. Don't start block sync if we're doing a state sync first. + bcReactor, err := createBlockchainReactor(config, state, blockExec, blockStore, blockSync && !stateSync, logger) if err != nil { return nil, fmt.Errorf("could not create blockchain reactor: %w", err) } - // Make ConsensusReactor. Don't enable fully if doing a state sync and/or fast sync first. + // Make ConsensusReactor. Don't enable fully if doing a state sync and/or block sync first. // FIXME We need to update metrics here, since other reactors don't have access to them. if stateSync { csMetrics.StateSyncing.Set(1) - } else if fastSync { - csMetrics.FastSyncing.Set(1) + } else if blockSync { + csMetrics.BlockSyncing.Set(1) } consensusReactor, consensusState := createConsensusReactor( config, state, blockExec, blockStore, mempool, evidencePool, - privValidator, csMetrics, stateSync || fastSync, eventBus, consensusLogger, + privValidator, csMetrics, stateSync || blockSync, eventBus, consensusLogger, ) // Set up state sync reactor, and schedule a sync if requested. - // FIXME The way we do phased startups (e.g. replay -> fast sync -> consensus) is very messy, + // FIXME The way we do phased startups (e.g. replay -> block sync -> consensus) is very messy, // we should clean this whole thing up. See: // https://github.com/tendermint/tendermint/issues/4644 stateSyncReactor := statesync.NewReactor( @@ -982,12 +982,12 @@ func (n *Node) OnStart() error { // Run state sync if n.stateSync { - bcR, ok := n.bcReactor.(fastSyncReactor) + bcR, ok := n.bcReactor.(blockSyncReactor) if !ok { return fmt.Errorf("this blockchain reactor does not support switching from state sync") } err := startStateSync(n.stateSyncReactor, bcR, n.consensusReactor, n.stateSyncProvider, - n.config.StateSync, n.config.FastSyncMode, n.stateStore, n.blockStore, n.stateSyncGenesis) + n.config.StateSync, n.config.BlockSyncMode, n.stateStore, n.blockStore, n.stateSyncGenesis) if err != nil { return fmt.Errorf("failed to start state sync: %w", err) } @@ -1335,7 +1335,7 @@ func makeNodeInfo( Network: genDoc.ChainID, Version: version.TMCoreSemVer, Channels: []byte{ - bc.BlockchainChannel, + bc.BlocksyncChannel, cs.StateChannel, cs.DataChannel, cs.VoteChannel, cs.VoteSetBitsChannel, mempl.MempoolChannel, evidence.EvidenceChannel, diff --git a/proto/tendermint/blockchain/types.pb.go b/proto/tendermint/blocksync/types.pb.go similarity index 90% rename from proto/tendermint/blockchain/types.pb.go rename to proto/tendermint/blocksync/types.pb.go index bc160b230..fcbef7107 100644 --- a/proto/tendermint/blockchain/types.pb.go +++ b/proto/tendermint/blocksync/types.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: tendermint/blockchain/types.proto +// source: tendermint/blocksync/types.proto -package blockchain +package blocksync import ( fmt "fmt" @@ -32,7 +32,7 @@ func (m *BlockRequest) Reset() { *m = BlockRequest{} } func (m *BlockRequest) String() string { return proto.CompactTextString(m) } func (*BlockRequest) ProtoMessage() {} func (*BlockRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_2927480384e78499, []int{0} + return fileDescriptor_19b397c236e0fa07, []int{0} } func (m *BlockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -77,7 +77,7 @@ func (m *NoBlockResponse) Reset() { *m = NoBlockResponse{} } func (m *NoBlockResponse) String() string { return proto.CompactTextString(m) } func (*NoBlockResponse) ProtoMessage() {} func (*NoBlockResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_2927480384e78499, []int{1} + return fileDescriptor_19b397c236e0fa07, []int{1} } func (m *NoBlockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -122,7 +122,7 @@ func (m *BlockResponse) Reset() { *m = BlockResponse{} } func (m *BlockResponse) String() string { return proto.CompactTextString(m) } func (*BlockResponse) ProtoMessage() {} func (*BlockResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_2927480384e78499, []int{2} + return fileDescriptor_19b397c236e0fa07, []int{2} } func (m *BlockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -166,7 +166,7 @@ func (m *StatusRequest) Reset() { *m = StatusRequest{} } func (m *StatusRequest) String() string { return proto.CompactTextString(m) } func (*StatusRequest) ProtoMessage() {} func (*StatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_2927480384e78499, []int{3} + return fileDescriptor_19b397c236e0fa07, []int{3} } func (m *StatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -205,7 +205,7 @@ func (m *StatusResponse) Reset() { *m = StatusResponse{} } func (m *StatusResponse) String() string { return proto.CompactTextString(m) } func (*StatusResponse) ProtoMessage() {} func (*StatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_2927480384e78499, []int{4} + return fileDescriptor_19b397c236e0fa07, []int{4} } func (m *StatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -262,7 +262,7 @@ func (m *Message) Reset() { *m = Message{} } func (m *Message) String() string { return proto.CompactTextString(m) } func (*Message) ProtoMessage() {} func (*Message) Descriptor() ([]byte, []int) { - return fileDescriptor_2927480384e78499, []int{5} + return fileDescriptor_19b397c236e0fa07, []int{5} } func (m *Message) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -373,42 +373,41 @@ func (*Message) XXX_OneofWrappers() []interface{} { } func init() { - proto.RegisterType((*BlockRequest)(nil), "tendermint.blockchain.BlockRequest") - proto.RegisterType((*NoBlockResponse)(nil), "tendermint.blockchain.NoBlockResponse") - proto.RegisterType((*BlockResponse)(nil), "tendermint.blockchain.BlockResponse") - proto.RegisterType((*StatusRequest)(nil), "tendermint.blockchain.StatusRequest") - proto.RegisterType((*StatusResponse)(nil), "tendermint.blockchain.StatusResponse") - proto.RegisterType((*Message)(nil), "tendermint.blockchain.Message") + proto.RegisterType((*BlockRequest)(nil), "tendermint.blocksync.BlockRequest") + proto.RegisterType((*NoBlockResponse)(nil), "tendermint.blocksync.NoBlockResponse") + proto.RegisterType((*BlockResponse)(nil), "tendermint.blocksync.BlockResponse") + proto.RegisterType((*StatusRequest)(nil), "tendermint.blocksync.StatusRequest") + proto.RegisterType((*StatusResponse)(nil), "tendermint.blocksync.StatusResponse") + proto.RegisterType((*Message)(nil), "tendermint.blocksync.Message") } -func init() { proto.RegisterFile("tendermint/blockchain/types.proto", fileDescriptor_2927480384e78499) } +func init() { proto.RegisterFile("tendermint/blocksync/types.proto", fileDescriptor_19b397c236e0fa07) } -var fileDescriptor_2927480384e78499 = []byte{ - // 370 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xc1, 0x4e, 0xfa, 0x40, - 0x10, 0xc6, 0xdb, 0x7f, 0x81, 0x7f, 0x32, 0x50, 0x1a, 0x9b, 0xa8, 0xc4, 0x98, 0x46, 0xab, 0x12, - 0x3d, 0xd8, 0x26, 0x78, 0x25, 0x1e, 0x38, 0x11, 0x13, 0x8c, 0xa9, 0xc6, 0x83, 0x17, 0xd2, 0xe2, - 0x86, 0x36, 0x4a, 0x17, 0xd9, 0xed, 0xc1, 0xb7, 0xf0, 0x19, 0x7c, 0x1a, 0x8f, 0x1c, 0x3d, 0x1a, - 0x78, 0x11, 0xc3, 0x6c, 0x29, 0x4b, 0x03, 0xf5, 0xb6, 0x3b, 0xfd, 0xe6, 0x37, 0xdf, 0x7e, 0x99, - 0xc2, 0x31, 0x27, 0xf1, 0x33, 0x99, 0x8c, 0xa2, 0x98, 0xbb, 0xc1, 0x2b, 0x1d, 0xbc, 0x0c, 0x42, - 0x3f, 0x8a, 0x5d, 0xfe, 0x3e, 0x26, 0xcc, 0x19, 0x4f, 0x28, 0xa7, 0xe6, 0xee, 0x4a, 0xe2, 0xac, - 0x24, 0x07, 0x87, 0x52, 0x27, 0xca, 0x45, 0xbf, 0x68, 0xb2, 0x9b, 0x50, 0xeb, 0x2c, 0xae, 0x1e, - 0x79, 0x4b, 0x08, 0xe3, 0xe6, 0x1e, 0x54, 0x42, 0x12, 0x0d, 0x43, 0xde, 0x50, 0x8f, 0xd4, 0x73, - 0xcd, 0x4b, 0x6f, 0xf6, 0x05, 0x18, 0xb7, 0x34, 0x55, 0xb2, 0x31, 0x8d, 0x19, 0xd9, 0x2a, 0xbd, - 0x06, 0x7d, 0x5d, 0x78, 0x09, 0x65, 0x1c, 0x89, 0xba, 0x6a, 0x6b, 0xdf, 0x91, 0x8c, 0x8a, 0x07, - 0x08, 0xbd, 0x50, 0xd9, 0x06, 0xe8, 0xf7, 0xdc, 0xe7, 0x09, 0x4b, 0x3d, 0xd9, 0x6d, 0xa8, 0x2f, - 0x0b, 0xc5, 0xa3, 0x4d, 0x13, 0x4a, 0x81, 0xcf, 0x48, 0xe3, 0x1f, 0x56, 0xf1, 0x6c, 0x7f, 0x6a, - 0xf0, 0xbf, 0x47, 0x18, 0xf3, 0x87, 0xc4, 0xbc, 0x01, 0x1d, 0x67, 0xf4, 0x27, 0x02, 0x9d, 0x3a, - 0x3a, 0x71, 0x36, 0x46, 0xe7, 0xc8, 0xc9, 0x74, 0x15, 0xaf, 0x16, 0xc8, 0x49, 0x3d, 0xc0, 0x4e, - 0x4c, 0xfb, 0x4b, 0x9c, 0x30, 0x86, 0x83, 0xab, 0xad, 0xe6, 0x16, 0x5e, 0x2e, 0xc1, 0xae, 0xe2, - 0x19, 0x71, 0x2e, 0xd4, 0x1e, 0xd4, 0x73, 0x48, 0x0d, 0x91, 0xa7, 0xc5, 0x16, 0x33, 0xa0, 0x1e, - 0xe4, 0x71, 0x0c, 0xa3, 0xcb, 0x5e, 0x5c, 0x2a, 0xc4, 0xad, 0x05, 0xbf, 0xc0, 0x31, 0xb9, 0x60, - 0xde, 0x81, 0x91, 0xe1, 0x52, 0x7b, 0x65, 0xe4, 0x9d, 0xfd, 0xc1, 0xcb, 0xfc, 0xd5, 0xd9, 0x5a, - 0xa5, 0x53, 0x06, 0x8d, 0x25, 0xa3, 0xce, 0xe3, 0xd7, 0xcc, 0x52, 0xa7, 0x33, 0x4b, 0xfd, 0x99, - 0x59, 0xea, 0xc7, 0xdc, 0x52, 0xa6, 0x73, 0x4b, 0xf9, 0x9e, 0x5b, 0xca, 0x53, 0x7b, 0x18, 0xf1, - 0x30, 0x09, 0x9c, 0x01, 0x1d, 0xb9, 0xf2, 0x26, 0xaf, 0x8e, 0xb8, 0xc8, 0xee, 0xc6, 0xff, 0x23, - 0xa8, 0xe0, 0xc7, 0xab, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5e, 0x59, 0x07, 0xbd, 0x3f, 0x03, - 0x00, 0x00, +var fileDescriptor_19b397c236e0fa07 = []byte{ + // 368 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x4d, 0x4f, 0xfa, 0x40, + 0x10, 0xc6, 0xdb, 0x7f, 0x81, 0x7f, 0x32, 0x50, 0x1a, 0x1b, 0xa3, 0xc4, 0x98, 0x86, 0xd4, 0x97, + 0xe8, 0xc1, 0x36, 0xc1, 0xa3, 0xc6, 0x03, 0x27, 0x4c, 0x7c, 0x49, 0x4a, 0xbc, 0x78, 0x21, 0x14, + 0x37, 0x40, 0x94, 0x2e, 0x32, 0xdb, 0x03, 0xdf, 0xc2, 0x2f, 0xe0, 0xf7, 0xf1, 0xc8, 0xd1, 0xa3, + 0x81, 0x2f, 0x62, 0x98, 0x2d, 0x65, 0x69, 0xb0, 0xb7, 0xdd, 0xe9, 0x33, 0xbf, 0x79, 0xfa, 0x64, + 0x16, 0xea, 0x82, 0x45, 0x2f, 0x6c, 0x32, 0x1a, 0x46, 0xc2, 0x0f, 0xdf, 0x78, 0xef, 0x15, 0xa7, + 0x51, 0xcf, 0x17, 0xd3, 0x31, 0x43, 0x6f, 0x3c, 0xe1, 0x82, 0xdb, 0xbb, 0x6b, 0x85, 0x97, 0x2a, + 0x0e, 0x0e, 0x95, 0x3e, 0x52, 0xcb, 0x6e, 0xd9, 0xe3, 0x9e, 0x42, 0xa5, 0xb9, 0xbc, 0x06, 0xec, + 0x3d, 0x66, 0x28, 0xec, 0x3d, 0x28, 0x0d, 0xd8, 0xb0, 0x3f, 0x10, 0x35, 0xbd, 0xae, 0x9f, 0x19, + 0x41, 0x72, 0x73, 0xcf, 0xc1, 0x7a, 0xe0, 0x89, 0x12, 0xc7, 0x3c, 0x42, 0xf6, 0xa7, 0xf4, 0x06, + 0xcc, 0x4d, 0xe1, 0x05, 0x14, 0x69, 0x24, 0xe9, 0xca, 0x8d, 0x7d, 0x4f, 0xf1, 0x29, 0xfd, 0x4b, + 0xbd, 0x54, 0xb9, 0x16, 0x98, 0x6d, 0xd1, 0x15, 0x31, 0x26, 0x9e, 0xdc, 0x6b, 0xa8, 0xae, 0x0a, + 0xf9, 0xa3, 0x6d, 0x1b, 0x0a, 0x61, 0x17, 0x59, 0xed, 0x1f, 0x55, 0xe9, 0xec, 0x7e, 0x1a, 0xf0, + 0xff, 0x9e, 0x21, 0x76, 0xfb, 0xcc, 0xbe, 0x05, 0x93, 0x66, 0x74, 0x26, 0x12, 0x9d, 0x38, 0x72, + 0xbd, 0x6d, 0xc9, 0x79, 0x6a, 0x30, 0x2d, 0x2d, 0xa8, 0x84, 0x6a, 0x50, 0x6d, 0xd8, 0x89, 0x78, + 0x67, 0x45, 0x93, 0xbe, 0x68, 0x6e, 0xb9, 0x71, 0xb2, 0x1d, 0x97, 0xc9, 0xaf, 0xa5, 0x05, 0x56, + 0x94, 0x89, 0xf4, 0x0e, 0xaa, 0x19, 0xa2, 0x41, 0xc4, 0xa3, 0x5c, 0x83, 0x29, 0xcf, 0x0c, 0xb3, + 0x34, 0xa4, 0xdc, 0xd2, 0xdf, 0x2d, 0xe4, 0xd1, 0x36, 0x42, 0x5f, 0xd2, 0x50, 0x2d, 0xd8, 0x8f, + 0x60, 0xa5, 0xb4, 0xc4, 0x5c, 0x91, 0x70, 0xc7, 0xf9, 0xb8, 0xd4, 0x5d, 0x15, 0x37, 0x2a, 0xcd, + 0x22, 0x18, 0x18, 0x8f, 0x9a, 0x4f, 0x5f, 0x73, 0x47, 0x9f, 0xcd, 0x1d, 0xfd, 0x67, 0xee, 0xe8, + 0x1f, 0x0b, 0x47, 0x9b, 0x2d, 0x1c, 0xed, 0x7b, 0xe1, 0x68, 0xcf, 0x57, 0xfd, 0xa1, 0x18, 0xc4, + 0xa1, 0xd7, 0xe3, 0x23, 0x5f, 0x5d, 0xe2, 0xf5, 0x91, 0x76, 0xd8, 0xdf, 0xf6, 0x30, 0xc2, 0x12, + 0x7d, 0xbb, 0xfc, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xf5, 0x1c, 0xa3, 0x45, 0x37, 0x03, 0x00, 0x00, } func (m *BlockRequest) Marshal() (dAtA []byte, err error) { diff --git a/proto/tendermint/blockchain/types.proto b/proto/tendermint/blocksync/types.proto similarity index 94% rename from proto/tendermint/blockchain/types.proto rename to proto/tendermint/blocksync/types.proto index f5c143cf5..8c187c793 100644 --- a/proto/tendermint/blockchain/types.proto +++ b/proto/tendermint/blocksync/types.proto @@ -1,7 +1,7 @@ syntax = "proto3"; -package tendermint.blockchain; +package tendermint.blocksync; -option go_package = "github.com/tendermint/tendermint/proto/tendermint/blockchain"; +option go_package = "github.com/tendermint/tendermint/proto/tendermint/blocksync"; import "tendermint/types/block.proto"; diff --git a/spec/abci/abci.md b/spec/abci/abci.md index 634daec68..5ce004275 100644 --- a/spec/abci/abci.md +++ b/spec/abci/abci.md @@ -643,7 +643,7 @@ the blockchain's `AppHash` which is verified via [light client verification](../ `Snapshot.Metadata` and/or incrementally verifying contents against `AppHash`. * When all chunks have been accepted, Tendermint will make an ABCI `Info` call to verify that `LastBlockAppHash` and `LastBlockHeight` matches the expected values, and record the - `AppVersion` in the node state. It then switches to fast sync or consensus and joins the + `AppVersion` in the node state. It then switches to block sync or consensus and joins the network. * If Tendermint is unable to retrieve the next chunk after some time (e.g. because no suitable peers are available), it will reject the snapshot and try a different one via `OfferSnapshot`. diff --git a/spec/p2p/messages/block-sync.md b/spec/p2p/messages/block-sync.md index 48aa6155f..122702f4f 100644 --- a/spec/p2p/messages/block-sync.md +++ b/spec/p2p/messages/block-sync.md @@ -10,7 +10,7 @@ Block sync has one channel. | Name | Number | |-------------------|--------| -| BlockchainChannel | 64 | +| BlocksyncChannel | 64 | ## Message Types diff --git a/test/e2e/README.md b/test/e2e/README.md index 4f89d2885..70a63dac5 100644 --- a/test/e2e/README.md +++ b/test/e2e/README.md @@ -160,4 +160,4 @@ tendermint start ./build/node ./node.socket.toml ``` -Check `node/config.go` to see how the settings of the test application can be tweaked. \ No newline at end of file +Check `node/config.go` to see how the settings of the test application can be tweaked. diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go index e203e4d6b..684acb426 100644 --- a/test/e2e/generator/generate.go +++ b/test/e2e/generator/generate.go @@ -28,7 +28,7 @@ var ( // FIXME: grpc disabled due to https://github.com/tendermint/tendermint/issues/5439 nodeABCIProtocols = uniformChoice{"unix", "tcp", "builtin"} // "grpc" nodePrivvalProtocols = uniformChoice{"file", "unix", "tcp"} - nodeFastSyncs = uniformChoice{false, true} + nodeBlockSyncs = uniformChoice{"v0"} // "v2" nodeStateSyncs = uniformChoice{false, true} nodeMempools = uniformChoice{"v0", "v1"} nodePersistIntervals = uniformChoice{0, 1, 5} @@ -201,7 +201,7 @@ func generateNode( StartAt: startAt, Database: nodeDatabases.Choose(r).(string), PrivvalProtocol: nodePrivvalProtocols.Choose(r).(string), - FastSync: nodeFastSyncs.Choose(r).(bool), + BlockSync: nodeBlockSyncs.Choose(r).(string), Mempool: nodeMempools.Choose(r).(string), StateSync: nodeStateSyncs.Choose(r).(bool) && startAt > 0, PersistInterval: ptrUint64(uint64(nodePersistIntervals.Choose(r).(int))), diff --git a/test/e2e/networks/ci.toml b/test/e2e/networks/ci.toml index 1fff574ca..e210db379 100644 --- a/test/e2e/networks/ci.toml +++ b/test/e2e/networks/ci.toml @@ -63,10 +63,10 @@ abci_protocol = "builtin" perturb = ["pause"] [node.validator05] +block_sync = "v0" start_at = 1005 # Becomes part of the validator set at 1010 seeds = ["seed02"] database = "cleveldb" -fast_sync = true mempool_version = "v1" # FIXME: should be grpc, disabled due to https://github.com/tendermint/tendermint/issues/5439 #abci_protocol = "grpc" @@ -76,7 +76,7 @@ perturb = ["kill", "pause", "disconnect", "restart"] [node.full01] start_at = 1010 mode = "full" -fast_sync = true +block_sync = "v0" persistent_peers = ["validator01", "validator02", "validator03", "validator04", "validator05"] retain_blocks = 1 perturb = ["restart"] @@ -84,7 +84,7 @@ perturb = ["restart"] [node.full02] start_at = 1015 mode = "full" -fast_sync = true +block_sync = "v0" state_sync = true seeds = ["seed01"] perturb = ["restart"] @@ -97,4 +97,4 @@ persistent_peers = ["validator01", "validator02", "validator03"] [node.light02] mode= "light" start_at= 1015 -persistent_peers = ["validator04", "full01", "validator05"] \ No newline at end of file +persistent_peers = ["validator04", "full01", "validator05"] diff --git a/test/e2e/pkg/manifest.go b/test/e2e/pkg/manifest.go index 44c8e9118..6099ab492 100644 --- a/test/e2e/pkg/manifest.go +++ b/test/e2e/pkg/manifest.go @@ -88,8 +88,9 @@ type ManifestNode struct { // runner will wait for the network to reach at least this block height. StartAt int64 `toml:"start_at"` - // FastSync specifies whether to enable the fast sync protocol. - FastSync bool `toml:"fast_sync"` + // BlockSync specifies the block sync mode: "" (disable), "v0" or "v2". + // Defaults to disabled. + BlockSync string `toml:"block_sync"` // Mempool specifies which version of mempool to use. Either "v0" or "v1" // This defaults to v0. diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go index 1123c26a9..3d213f381 100644 --- a/test/e2e/pkg/testnet.go +++ b/test/e2e/pkg/testnet.go @@ -72,7 +72,7 @@ type Node struct { IP net.IP ProxyPort uint32 StartAt int64 - FastSync bool + BlockSync string StateSync bool Mempool string Database string @@ -155,7 +155,7 @@ func LoadTestnet(file string) (*Testnet, error) { ABCIProtocol: Protocol(testnet.ABCIProtocol), PrivvalProtocol: ProtocolFile, StartAt: nodeManifest.StartAt, - FastSync: nodeManifest.FastSync, + BlockSync: nodeManifest.BlockSync, Mempool: nodeManifest.Mempool, StateSync: nodeManifest.StateSync, PersistInterval: 1, @@ -297,6 +297,11 @@ func (n Node) Validate(testnet Testnet) error { } } } + switch n.BlockSync { + case "", "v0": + default: + return fmt.Errorf("invalid block sync setting %q", n.BlockSync) + } switch n.Mempool { case "", "v0", "v1": default: diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go index 2dd84eaf2..311b1dda2 100644 --- a/test/e2e/runner/setup.go +++ b/test/e2e/runner/setup.go @@ -284,7 +284,11 @@ func MakeConfig(node *e2e.Node) (*config.Config, error) { cfg.Mempool.Version = node.Mempool } - cfg.FastSyncMode = node.FastSync + if node.BlockSync == "" { + cfg.BlockSyncMode = false + } else { + cfg.BlockSync.Version = node.BlockSync + } if node.StateSync { cfg.StateSync.Enable = true