From a341a626e0e3431b657535ddc4f43456b25a040f Mon Sep 17 00:00:00 2001 From: Callum Waters Date: Mon, 26 Jul 2021 15:09:07 +0200 Subject: [PATCH 01/35] p2p: avoid blocking on the dequeCh (#6765) --- internal/p2p/pqueue.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/internal/p2p/pqueue.go b/internal/p2p/pqueue.go index 0e62c87d9..e4560c7bd 100644 --- a/internal/p2p/pqueue.go +++ b/internal/p2p/pqueue.go @@ -257,7 +257,11 @@ func (s *pqScheduler) process() { s.metrics.PeerSendBytesTotal.With( "chID", chIDStr, "peer_id", string(pqEnv.envelope.To)).Add(float64(pqEnv.size)) - s.dequeueCh <- pqEnv.envelope + select { + case s.dequeueCh <- pqEnv.envelope: + case <-s.closer.Done(): + return + } } case <-s.closer.Done(): From 91e277d7b7d087c78397353d4d29eec3c84af13f Mon Sep 17 00:00:00 2001 From: Callum Waters Date: Mon, 26 Jul 2021 15:22:12 +0200 Subject: [PATCH 02/35] enable pex reactor depending on config param (#6762) --- node/node.go | 52 +++++++++++++++++++++++++++------------------------- 1 file changed, 27 insertions(+), 25 deletions(-) diff --git a/node/node.go b/node/node.go index cb32c5ce6..994132b29 100644 --- a/node/node.go +++ b/node/node.go @@ -380,35 +380,37 @@ func makeNode(config *cfg.Config, pexCh := pex.ChannelDescriptor() transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh}) - if config.P2P.DisableLegacy { - addrBook = nil - pexReactorV2, err = createPEXReactorV2(config, logger, peerManager, router) - if err != nil { - return nil, err - } - } else { - // setup Transport and Switch - sw = createSwitch( - config, transport, p2pMetrics, mpReactorShim, bcReactorForSwitch, - stateSyncReactorShim, csReactorShim, evReactorShim, proxyApp, nodeInfo, nodeKey, p2pLogger, - ) + if config.P2P.PexReactor { + if config.P2P.DisableLegacy { + addrBook = nil + pexReactorV2, err = createPEXReactorV2(config, logger, peerManager, router) + if err != nil { + return nil, err + } + } else { + // setup Transport and Switch + sw = createSwitch( + config, transport, p2pMetrics, mpReactorShim, bcReactorForSwitch, + stateSyncReactorShim, csReactorShim, evReactorShim, proxyApp, nodeInfo, nodeKey, p2pLogger, + ) - err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) - if err != nil { - return nil, fmt.Errorf("could not add peers from persistent-peers field: %w", err) - } + err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) + if err != nil { + return nil, fmt.Errorf("could not add peers from persistent-peers field: %w", err) + } - err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) - if err != nil { - return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) - } + err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) + if err != nil { + return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) + } - addrBook, err = createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) - if err != nil { - return nil, fmt.Errorf("could not create addrbook: %w", err) - } + addrBook, err = createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) + if err != nil { + return nil, fmt.Errorf("could not create addrbook: %w", err) + } - pexReactor = createPEXReactorAndAddToSwitch(addrBook, config, sw, logger) + pexReactor = createPEXReactorAndAddToSwitch(addrBook, config, sw, logger) + } } if config.RPC.PprofListenAddress != "" { From 93f462ef869b1b3fc36bfa6af89cd073f3f66031 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 26 Jul 2021 14:17:02 +0000 Subject: [PATCH 03/35] build(deps): Bump codecov/codecov-action from 2.0.1 to 2.0.2 (#6764) Bumps [codecov/codecov-action](https://github.com/codecov/codecov-action) from 2.0.1 to 2.0.2. - [Release notes](https://github.com/codecov/codecov-action/releases) - [Changelog](https://github.com/codecov/codecov-action/blob/master/CHANGELOG.md) - [Commits](https://github.com/codecov/codecov-action/compare/v2.0.1...v2.0.2) --- updated-dependencies: - dependency-name: codecov/codecov-action dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Marko --- .github/workflows/coverage.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index ee6b0068f..7d7ab8113 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -121,7 +121,7 @@ jobs: - run: | cat ./*profile.out | grep -v "mode: atomic" >> coverage.txt if: env.GIT_DIFF - - uses: codecov/codecov-action@v2.0.1 + - uses: codecov/codecov-action@v2.0.2 with: file: ./coverage.txt if: env.GIT_DIFF From c5dc3b267f68e167c0e58bdcf50a29ff4df48349 Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Mon, 26 Jul 2021 10:58:51 -0400 Subject: [PATCH 04/35] test/fuzz: add test to reproduce found fuzz errors (#6757) This change does two things: 1. It fixes the json fuzzer to account for receiving array results. Arrays are returned by the rpc server when the input data is an array. 2. Adds a `fuzz_test.go` file and corresponding `testdata` directory containing the failing test case. This seems like a reasonable way to add and track previous crash issues in our fuzz test cases. The upcoming stdlib go fuzz tool does effectively this automatically. --- test/fuzz/rpc/jsonrpc/server/fuzz_test.go | 33 +++++++++++++++++++ test/fuzz/rpc/jsonrpc/server/handler.go | 23 ++++++++++--- .../1184f5b8d4b6dd08709cf1513f26744167065e0d | 1 + ...d-fuzz_rpc_jsonrpc_server-4738572803506176 | 1 + 4 files changed, 54 insertions(+), 4 deletions(-) create mode 100644 test/fuzz/rpc/jsonrpc/server/fuzz_test.go create mode 100644 test/fuzz/rpc/jsonrpc/server/testdata/1184f5b8d4b6dd08709cf1513f26744167065e0d create mode 100644 test/fuzz/rpc/jsonrpc/server/testdata/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 diff --git a/test/fuzz/rpc/jsonrpc/server/fuzz_test.go b/test/fuzz/rpc/jsonrpc/server/fuzz_test.go new file mode 100644 index 000000000..005248375 --- /dev/null +++ b/test/fuzz/rpc/jsonrpc/server/fuzz_test.go @@ -0,0 +1,33 @@ +package server_test + +import ( + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/test/fuzz/rpc/jsonrpc/server" +) + +const testdataDir = "testdata" + +func TestServerOnTestData(t *testing.T) { + entries, err := os.ReadDir(testdataDir) + require.NoError(t, err) + + for _, e := range entries { + entry := e + t.Run(entry.Name(), func(t *testing.T) { + defer func() { + r := recover() + require.Nilf(t, r, "testdata test panic") + }() + f, err := os.Open(filepath.Join(testdataDir, entry.Name())) + require.NoError(t, err) + input, err := ioutil.ReadAll(f) + require.NoError(t, err) + server.Fuzz(input) + }) + } +} diff --git a/test/fuzz/rpc/jsonrpc/server/handler.go b/test/fuzz/rpc/jsonrpc/server/handler.go index cab1b6ed0..c30a8890c 100644 --- a/test/fuzz/rpc/jsonrpc/server/handler.go +++ b/test/fuzz/rpc/jsonrpc/server/handler.go @@ -1,4 +1,4 @@ -package handler +package server import ( "bytes" @@ -39,11 +39,26 @@ func Fuzz(data []byte) int { if err := res.Body.Close(); err != nil { panic(err) } - if len(blob) > 0 { - recv := new(types.RPCResponse) - if err := json.Unmarshal(blob, recv); err != nil { + if len(blob) == 0 { + return 1 + } + + if inputJSONIsMultiElementSlice(data) { + recv := []types.RPCResponse{} + if err := json.Unmarshal(blob, &recv); err != nil { panic(err) } + return 1 + } + recv := &types.RPCResponse{} + if err := json.Unmarshal(blob, recv); err != nil { + panic(err) } return 1 } + +func inputJSONIsMultiElementSlice(input []byte) bool { + slice := []interface{}{} + err := json.Unmarshal(input, &slice) + return err == nil && len(slice) > 1 +} diff --git a/test/fuzz/rpc/jsonrpc/server/testdata/1184f5b8d4b6dd08709cf1513f26744167065e0d b/test/fuzz/rpc/jsonrpc/server/testdata/1184f5b8d4b6dd08709cf1513f26744167065e0d new file mode 100644 index 000000000..6e7ea636e --- /dev/null +++ b/test/fuzz/rpc/jsonrpc/server/testdata/1184f5b8d4b6dd08709cf1513f26744167065e0d @@ -0,0 +1 @@ +[0] \ No newline at end of file diff --git a/test/fuzz/rpc/jsonrpc/server/testdata/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 b/test/fuzz/rpc/jsonrpc/server/testdata/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 new file mode 100644 index 000000000..0f7836d2f --- /dev/null +++ b/test/fuzz/rpc/jsonrpc/server/testdata/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 @@ -0,0 +1 @@ +[{"iD":7},{"iD":7}] \ No newline at end of file From a751eee7f25e49834f3d13044498e2e7c28fa502 Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Mon, 26 Jul 2021 15:22:32 -0400 Subject: [PATCH 05/35] p2p: add test for pqueue dequeue full error (#6760) This adds a test for closing the `pqueue` while the `pqueue` contains data that has not yet been dequeued. This issue was found while debugging #6705 This test will fail until @cmwaters fix for this condition is merged. --- internal/p2p/pqueue_test.go | 39 +++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 internal/p2p/pqueue_test.go diff --git a/internal/p2p/pqueue_test.go b/internal/p2p/pqueue_test.go new file mode 100644 index 000000000..ddb7addbe --- /dev/null +++ b/internal/p2p/pqueue_test.go @@ -0,0 +1,39 @@ +package p2p + +import ( + "testing" + "time" + + "github.com/tendermint/tendermint/libs/log" +) + +func TestCloseWhileDequeueFull(t *testing.T) { + enqueueLength := 5 + chDescs := []ChannelDescriptor{ + {ID: 0x01, Priority: 1, MaxSendBytes: 4}, + } + pqueue := newPQScheduler(log.NewNopLogger(), NopMetrics(), chDescs, uint(enqueueLength), 1, 120) + + for i := 0; i < enqueueLength; i++ { + pqueue.enqueue() <- Envelope{ + channelID: 0x01, + Message: &testMessage{Value: "foo"}, // 5 bytes + } + } + + go pqueue.process() + + // sleep to allow context switch for process() to run + time.Sleep(10 * time.Millisecond) + doneCh := make(chan struct{}) + go func() { + pqueue.close() + close(doneCh) + }() + + select { + case <-doneCh: + case <-time.After(2 * time.Second): + t.Fatal("pqueue failed to close") + } +} From dd97ac6e1c8810a115e53a61c9a91dd40275b3fe Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Mon, 26 Jul 2021 17:30:43 -0400 Subject: [PATCH 06/35] test/fuzz: add mechanism to reproduce found fuzz errors (#6768) * test/fuzz: add test to reproduce found fuzz errors --- .github/workflows/fuzz-nightly.yml | 9 ++++- test/fuzz/Makefile | 19 ++++++++-- test/fuzz/mempool/{ => v0}/checktx.go | 2 +- test/fuzz/mempool/v0/fuzz_test.go | 33 +++++++++++++++++ test/fuzz/mempool/v0/testdata/cases/empty | 0 test/fuzz/mempool/v1/checktx.go | 37 +++++++++++++++++++ test/fuzz/mempool/v1/fuzz_test.go | 33 +++++++++++++++++ test/fuzz/mempool/v1/testdata/cases/empty | 0 test/fuzz/p2p/addrbook/fuzz.go | 2 +- test/fuzz/p2p/addrbook/fuzz_test.go | 33 +++++++++++++++++ test/fuzz/p2p/addrbook/testdata/cases/empty | 0 test/fuzz/p2p/pex/fuzz_test.go | 33 +++++++++++++++++ test/fuzz/p2p/pex/testdata/cases/empty | 0 test/fuzz/p2p/secretconnection/fuzz_test.go | 33 +++++++++++++++++ .../init-corpus/main.go | 0 .../read_write.go | 0 .../p2p/secretconnection/testdata/cases/empty | 0 test/fuzz/rpc/jsonrpc/server/fuzz_test.go | 10 ++--- test/fuzz/rpc/jsonrpc/server/handler.go | 6 +-- .../1184f5b8d4b6dd08709cf1513f26744167065e0d | 1 + .../bbcffb1cdb2cea50fd3dd8c1524905551d0b2e79 | 1 + ...d-fuzz_rpc_jsonrpc_server-4738572803506176 | 1 + .../rpc/jsonrpc/server/testdata/cases/empty | 0 23 files changed, 238 insertions(+), 15 deletions(-) rename test/fuzz/mempool/{ => v0}/checktx.go (97%) create mode 100644 test/fuzz/mempool/v0/fuzz_test.go create mode 100644 test/fuzz/mempool/v0/testdata/cases/empty create mode 100644 test/fuzz/mempool/v1/checktx.go create mode 100644 test/fuzz/mempool/v1/fuzz_test.go create mode 100644 test/fuzz/mempool/v1/testdata/cases/empty create mode 100644 test/fuzz/p2p/addrbook/fuzz_test.go create mode 100644 test/fuzz/p2p/addrbook/testdata/cases/empty create mode 100644 test/fuzz/p2p/pex/fuzz_test.go create mode 100644 test/fuzz/p2p/pex/testdata/cases/empty create mode 100644 test/fuzz/p2p/secretconnection/fuzz_test.go rename test/fuzz/p2p/{secret_connection => secretconnection}/init-corpus/main.go (100%) rename test/fuzz/p2p/{secret_connection => secretconnection}/read_write.go (100%) create mode 100644 test/fuzz/p2p/secretconnection/testdata/cases/empty create mode 100644 test/fuzz/rpc/jsonrpc/server/testdata/cases/1184f5b8d4b6dd08709cf1513f26744167065e0d create mode 100644 test/fuzz/rpc/jsonrpc/server/testdata/cases/bbcffb1cdb2cea50fd3dd8c1524905551d0b2e79 create mode 100644 test/fuzz/rpc/jsonrpc/server/testdata/cases/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 create mode 100644 test/fuzz/rpc/jsonrpc/server/testdata/cases/empty diff --git a/.github/workflows/fuzz-nightly.yml b/.github/workflows/fuzz-nightly.yml index 07392ae2b..c47dc4411 100644 --- a/.github/workflows/fuzz-nightly.yml +++ b/.github/workflows/fuzz-nightly.yml @@ -23,9 +23,14 @@ jobs: working-directory: test/fuzz run: go get -u github.com/dvyukov/go-fuzz/go-fuzz github.com/dvyukov/go-fuzz/go-fuzz-build - - name: Fuzz mempool + - name: Fuzz mempool-v1 working-directory: test/fuzz - run: timeout -s SIGINT --preserve-status 10m make fuzz-mempool + run: timeout -s SIGINT --preserve-status 10m make fuzz-mempool-v1 + continue-on-error: true + + - name: Fuzz mempool-v0 + working-directory: test/fuzz + run: timeout -s SIGINT --preserve-status 10m make fuzz-mempool-v0 continue-on-error: true - name: Fuzz p2p-addrbook diff --git a/test/fuzz/Makefile b/test/fuzz/Makefile index 96b332dcf..3d34e0a43 100644 --- a/test/fuzz/Makefile +++ b/test/fuzz/Makefile @@ -1,8 +1,15 @@ #!/usr/bin/make -f -.PHONY: fuzz-mempool -fuzz-mempool: - cd mempool && \ +.PHONY: fuzz-mempool-v1 +fuzz-mempool-v1: + cd mempool/v1 && \ + rm -f *-fuzz.zip && \ + go-fuzz-build && \ + go-fuzz + +.PHONY: fuzz-mempool-v0 +fuzz-mempool-v0: + cd mempool/v0 && \ rm -f *-fuzz.zip && \ go-fuzz-build && \ go-fuzz @@ -37,3 +44,9 @@ fuzz-rpc-server: rm -f *-fuzz.zip && \ go-fuzz-build && \ go-fuzz + +clean: + find . -name corpus -type d -exec rm -rf {} +; + find . -name crashers -type d -exec rm -rf {} +; + find . -name suppressions -type d -exec rm -rf {} +; + find . -name *\.zip -type f -delete diff --git a/test/fuzz/mempool/checktx.go b/test/fuzz/mempool/v0/checktx.go similarity index 97% rename from test/fuzz/mempool/checktx.go rename to test/fuzz/mempool/v0/checktx.go index 197b0daaf..a90ec2290 100644 --- a/test/fuzz/mempool/checktx.go +++ b/test/fuzz/mempool/v0/checktx.go @@ -1,4 +1,4 @@ -package checktx +package v0 import ( "context" diff --git a/test/fuzz/mempool/v0/fuzz_test.go b/test/fuzz/mempool/v0/fuzz_test.go new file mode 100644 index 000000000..4f8f1e9c8 --- /dev/null +++ b/test/fuzz/mempool/v0/fuzz_test.go @@ -0,0 +1,33 @@ +package v0_test + +import ( + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + mempoolv0 "github.com/tendermint/tendermint/test/fuzz/mempool/v0" +) + +const testdataCasesDir = "testdata/cases" + +func TestMempoolTestdataCases(t *testing.T) { + entries, err := os.ReadDir(testdataCasesDir) + require.NoError(t, err) + + for _, e := range entries { + entry := e + t.Run(entry.Name(), func(t *testing.T) { + defer func() { + r := recover() + require.Nilf(t, r, "testdata/cases test panic") + }() + f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name())) + require.NoError(t, err) + input, err := ioutil.ReadAll(f) + require.NoError(t, err) + mempoolv0.Fuzz(input) + }) + } +} diff --git a/test/fuzz/mempool/v0/testdata/cases/empty b/test/fuzz/mempool/v0/testdata/cases/empty new file mode 100644 index 000000000..e69de29bb diff --git a/test/fuzz/mempool/v1/checktx.go b/test/fuzz/mempool/v1/checktx.go new file mode 100644 index 000000000..6194f3bcb --- /dev/null +++ b/test/fuzz/mempool/v1/checktx.go @@ -0,0 +1,37 @@ +package v1 + +import ( + "context" + + "github.com/tendermint/tendermint/abci/example/kvstore" + "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/internal/mempool" + mempoolv1 "github.com/tendermint/tendermint/internal/mempool/v0" + "github.com/tendermint/tendermint/proxy" +) + +var mp mempool.Mempool + +func init() { + app := kvstore.NewApplication() + cc := proxy.NewLocalClientCreator(app) + appConnMem, _ := cc.NewABCIClient() + err := appConnMem.Start() + if err != nil { + panic(err) + } + + cfg := config.DefaultMempoolConfig() + cfg.Broadcast = false + + mp = mempoolv1.NewCListMempool(cfg, appConnMem, 0) +} + +func Fuzz(data []byte) int { + err := mp.CheckTx(context.Background(), data, nil, mempool.TxInfo{}) + if err != nil { + return 0 + } + + return 1 +} diff --git a/test/fuzz/mempool/v1/fuzz_test.go b/test/fuzz/mempool/v1/fuzz_test.go new file mode 100644 index 000000000..863697a0a --- /dev/null +++ b/test/fuzz/mempool/v1/fuzz_test.go @@ -0,0 +1,33 @@ +package v1_test + +import ( + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + mempoolv1 "github.com/tendermint/tendermint/test/fuzz/mempool/v1" +) + +const testdataCasesDir = "testdata/cases" + +func TestMempoolTestdataCases(t *testing.T) { + entries, err := os.ReadDir(testdataCasesDir) + require.NoError(t, err) + + for _, e := range entries { + entry := e + t.Run(entry.Name(), func(t *testing.T) { + defer func() { + r := recover() + require.Nilf(t, r, "testdata/cases test panic") + }() + f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name())) + require.NoError(t, err) + input, err := ioutil.ReadAll(f) + require.NoError(t, err) + mempoolv1.Fuzz(input) + }) + } +} diff --git a/test/fuzz/mempool/v1/testdata/cases/empty b/test/fuzz/mempool/v1/testdata/cases/empty new file mode 100644 index 000000000..e69de29bb diff --git a/test/fuzz/p2p/addrbook/fuzz.go b/test/fuzz/p2p/addrbook/fuzz.go index d0dfe6530..6d5548fc7 100644 --- a/test/fuzz/p2p/addrbook/fuzz.go +++ b/test/fuzz/p2p/addrbook/fuzz.go @@ -1,5 +1,5 @@ // nolint: gosec -package addr +package addrbook import ( "encoding/json" diff --git a/test/fuzz/p2p/addrbook/fuzz_test.go b/test/fuzz/p2p/addrbook/fuzz_test.go new file mode 100644 index 000000000..4ec7aebd9 --- /dev/null +++ b/test/fuzz/p2p/addrbook/fuzz_test.go @@ -0,0 +1,33 @@ +package addrbook_test + +import ( + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/test/fuzz/p2p/addrbook" +) + +const testdataCasesDir = "testdata/cases" + +func TestAddrbookTestdataCases(t *testing.T) { + entries, err := os.ReadDir(testdataCasesDir) + require.NoError(t, err) + + for _, e := range entries { + entry := e + t.Run(entry.Name(), func(t *testing.T) { + defer func() { + r := recover() + require.Nilf(t, r, "testdata/cases test panic") + }() + f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name())) + require.NoError(t, err) + input, err := ioutil.ReadAll(f) + require.NoError(t, err) + addrbook.Fuzz(input) + }) + } +} diff --git a/test/fuzz/p2p/addrbook/testdata/cases/empty b/test/fuzz/p2p/addrbook/testdata/cases/empty new file mode 100644 index 000000000..e69de29bb diff --git a/test/fuzz/p2p/pex/fuzz_test.go b/test/fuzz/p2p/pex/fuzz_test.go new file mode 100644 index 000000000..8a194e730 --- /dev/null +++ b/test/fuzz/p2p/pex/fuzz_test.go @@ -0,0 +1,33 @@ +package pex_test + +import ( + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/test/fuzz/p2p/pex" +) + +const testdataCasesDir = "testdata/cases" + +func TestPexTestdataCases(t *testing.T) { + entries, err := os.ReadDir(testdataCasesDir) + require.NoError(t, err) + + for _, e := range entries { + entry := e + t.Run(entry.Name(), func(t *testing.T) { + defer func() { + r := recover() + require.Nilf(t, r, "testdata/cases test panic") + }() + f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name())) + require.NoError(t, err) + input, err := ioutil.ReadAll(f) + require.NoError(t, err) + pex.Fuzz(input) + }) + } +} diff --git a/test/fuzz/p2p/pex/testdata/cases/empty b/test/fuzz/p2p/pex/testdata/cases/empty new file mode 100644 index 000000000..e69de29bb diff --git a/test/fuzz/p2p/secretconnection/fuzz_test.go b/test/fuzz/p2p/secretconnection/fuzz_test.go new file mode 100644 index 000000000..d48dc4267 --- /dev/null +++ b/test/fuzz/p2p/secretconnection/fuzz_test.go @@ -0,0 +1,33 @@ +package secretconnection_test + +import ( + "io/ioutil" + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/test/fuzz/p2p/secretconnection" +) + +const testdataCasesDir = "testdata/cases" + +func TestSecretConnectionTestdataCases(t *testing.T) { + entries, err := os.ReadDir(testdataCasesDir) + require.NoError(t, err) + + for _, e := range entries { + entry := e + t.Run(entry.Name(), func(t *testing.T) { + defer func() { + r := recover() + require.Nilf(t, r, "testdata/cases test panic") + }() + f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name())) + require.NoError(t, err) + input, err := ioutil.ReadAll(f) + require.NoError(t, err) + secretconnection.Fuzz(input) + }) + } +} diff --git a/test/fuzz/p2p/secret_connection/init-corpus/main.go b/test/fuzz/p2p/secretconnection/init-corpus/main.go similarity index 100% rename from test/fuzz/p2p/secret_connection/init-corpus/main.go rename to test/fuzz/p2p/secretconnection/init-corpus/main.go diff --git a/test/fuzz/p2p/secret_connection/read_write.go b/test/fuzz/p2p/secretconnection/read_write.go similarity index 100% rename from test/fuzz/p2p/secret_connection/read_write.go rename to test/fuzz/p2p/secretconnection/read_write.go diff --git a/test/fuzz/p2p/secretconnection/testdata/cases/empty b/test/fuzz/p2p/secretconnection/testdata/cases/empty new file mode 100644 index 000000000..e69de29bb diff --git a/test/fuzz/rpc/jsonrpc/server/fuzz_test.go b/test/fuzz/rpc/jsonrpc/server/fuzz_test.go index 005248375..50b9194fe 100644 --- a/test/fuzz/rpc/jsonrpc/server/fuzz_test.go +++ b/test/fuzz/rpc/jsonrpc/server/fuzz_test.go @@ -10,10 +10,10 @@ import ( "github.com/tendermint/tendermint/test/fuzz/rpc/jsonrpc/server" ) -const testdataDir = "testdata" +const testdataCasesDir = "testdata/cases" -func TestServerOnTestData(t *testing.T) { - entries, err := os.ReadDir(testdataDir) +func TestServerTestdataCases(t *testing.T) { + entries, err := os.ReadDir(testdataCasesDir) require.NoError(t, err) for _, e := range entries { @@ -21,9 +21,9 @@ func TestServerOnTestData(t *testing.T) { t.Run(entry.Name(), func(t *testing.T) { defer func() { r := recover() - require.Nilf(t, r, "testdata test panic") + require.Nilf(t, r, "testdata/cases test panic") }() - f, err := os.Open(filepath.Join(testdataDir, entry.Name())) + f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name())) require.NoError(t, err) input, err := ioutil.ReadAll(f) require.NoError(t, err) diff --git a/test/fuzz/rpc/jsonrpc/server/handler.go b/test/fuzz/rpc/jsonrpc/server/handler.go index c30a8890c..eed18ceff 100644 --- a/test/fuzz/rpc/jsonrpc/server/handler.go +++ b/test/fuzz/rpc/jsonrpc/server/handler.go @@ -43,7 +43,7 @@ func Fuzz(data []byte) int { return 1 } - if inputJSONIsMultiElementSlice(data) { + if outputJSONIsSlice(blob) { recv := []types.RPCResponse{} if err := json.Unmarshal(blob, &recv); err != nil { panic(err) @@ -57,8 +57,8 @@ func Fuzz(data []byte) int { return 1 } -func inputJSONIsMultiElementSlice(input []byte) bool { +func outputJSONIsSlice(input []byte) bool { slice := []interface{}{} err := json.Unmarshal(input, &slice) - return err == nil && len(slice) > 1 + return err == nil } diff --git a/test/fuzz/rpc/jsonrpc/server/testdata/cases/1184f5b8d4b6dd08709cf1513f26744167065e0d b/test/fuzz/rpc/jsonrpc/server/testdata/cases/1184f5b8d4b6dd08709cf1513f26744167065e0d new file mode 100644 index 000000000..6e7ea636e --- /dev/null +++ b/test/fuzz/rpc/jsonrpc/server/testdata/cases/1184f5b8d4b6dd08709cf1513f26744167065e0d @@ -0,0 +1 @@ +[0] \ No newline at end of file diff --git a/test/fuzz/rpc/jsonrpc/server/testdata/cases/bbcffb1cdb2cea50fd3dd8c1524905551d0b2e79 b/test/fuzz/rpc/jsonrpc/server/testdata/cases/bbcffb1cdb2cea50fd3dd8c1524905551d0b2e79 new file mode 100644 index 000000000..e0be2aa4b --- /dev/null +++ b/test/fuzz/rpc/jsonrpc/server/testdata/cases/bbcffb1cdb2cea50fd3dd8c1524905551d0b2e79 @@ -0,0 +1 @@ +[0,0] \ No newline at end of file diff --git a/test/fuzz/rpc/jsonrpc/server/testdata/cases/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 b/test/fuzz/rpc/jsonrpc/server/testdata/cases/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 new file mode 100644 index 000000000..0f7836d2f --- /dev/null +++ b/test/fuzz/rpc/jsonrpc/server/testdata/cases/clusterfuzz-testcase-minimized-fuzz_rpc_jsonrpc_server-4738572803506176 @@ -0,0 +1 @@ +[{"iD":7},{"iD":7}] \ No newline at end of file diff --git a/test/fuzz/rpc/jsonrpc/server/testdata/cases/empty b/test/fuzz/rpc/jsonrpc/server/testdata/cases/empty new file mode 100644 index 000000000..e69de29bb From 76376e3161594e18fa58e48da3bf509b8007bd41 Mon Sep 17 00:00:00 2001 From: Marko Date: Tue, 27 Jul 2021 06:17:32 +0000 Subject: [PATCH 07/35] avoid issues already labeled (#6767) --- .github/workflows/stale.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml index 929f0075e..1109f09c1 100644 --- a/.github/workflows/stale.yml +++ b/.github/workflows/stale.yml @@ -14,6 +14,7 @@ jobs: recent activity. It will be closed if no further activity occurs. Thank you for your contributions." days-before-stale: -1 + days-before-close: -1 days-before-pr-stale: 10 days-before-pr-close: 4 exempt-pr-labels: "S:wip" From 44ac57489fffccffa56430cd847f94588620f1ee Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Tue, 27 Jul 2021 09:33:20 -0400 Subject: [PATCH 08/35] abci: add changelog entry for mempool_error field (#6770) Follow up from PR: #6740 --- CHANGELOG_PENDING.md | 1 + abci/types/types.pb.go | 24 +++++++++++++----------- proto/tendermint/abci/types.proto | 25 ++++++++++++++----------- 3 files changed, 28 insertions(+), 22 deletions(-) diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md index 9c3add9b8..a800b8d33 100644 --- a/CHANGELOG_PENDING.md +++ b/CHANGELOG_PENDING.md @@ -30,6 +30,7 @@ Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermi - [ABCI] \#5447 Remove `SetOption` method from `ABCI.Client` interface - [ABCI] \#5447 Reset `Oneof` indexes for `Request` and `Response`. - [ABCI] \#5818 Use protoio for msg length delimitation. Migrates from int64 to uint64 length delimiters. + - [ABCI] \#3546 Add `mempool_error` field to `ResponseCheckTx`. This field will contain an error string if Tendermint encountered an error while adding a transaction to the mempool. (@williambanfield) - [Version] \#6494 `TMCoreSemVer` has been renamed to `TMVersion`. - It is not required any longer to set ldflags to set version strings - [abci/counter] \#6684 Delete counter example app diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go index f8781c0c4..6b00c587a 100644 --- a/abci/types/types.pb.go +++ b/abci/types/types.pb.go @@ -1827,17 +1827,19 @@ func (m *ResponseBeginBlock) GetEvents() []Event { } type ResponseCheckTx struct { - Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` - Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` - Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` - Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` - GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,proto3" json:"gas_wanted,omitempty"` - GasUsed int64 `protobuf:"varint,6,opt,name=gas_used,proto3" json:"gas_used,omitempty"` - Events []Event `protobuf:"bytes,7,rep,name=events,proto3" json:"events,omitempty"` - Codespace string `protobuf:"bytes,8,opt,name=codespace,proto3" json:"codespace,omitempty"` - Sender string `protobuf:"bytes,9,opt,name=sender,proto3" json:"sender,omitempty"` - Priority int64 `protobuf:"varint,10,opt,name=priority,proto3" json:"priority,omitempty"` - MempoolError string `protobuf:"bytes,11,opt,name=mempool_error,json=mempoolError,proto3" json:"mempool_error,omitempty"` + Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` + Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` + GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,proto3" json:"gas_wanted,omitempty"` + GasUsed int64 `protobuf:"varint,6,opt,name=gas_used,proto3" json:"gas_used,omitempty"` + Events []Event `protobuf:"bytes,7,rep,name=events,proto3" json:"events,omitempty"` + Codespace string `protobuf:"bytes,8,opt,name=codespace,proto3" json:"codespace,omitempty"` + Sender string `protobuf:"bytes,9,opt,name=sender,proto3" json:"sender,omitempty"` + Priority int64 `protobuf:"varint,10,opt,name=priority,proto3" json:"priority,omitempty"` + // mempool_error is set by Tendermint. + // ABCI applictions creating a ResponseCheckTX should not set mempool_error. + MempoolError string `protobuf:"bytes,11,opt,name=mempool_error,json=mempoolError,proto3" json:"mempool_error,omitempty"` } func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } diff --git a/proto/tendermint/abci/types.proto b/proto/tendermint/abci/types.proto index f0d70548e..7126488d0 100644 --- a/proto/tendermint/abci/types.proto +++ b/proto/tendermint/abci/types.proto @@ -186,17 +186,20 @@ message ResponseBeginBlock { } message ResponseCheckTx { - uint32 code = 1; - bytes data = 2; - string log = 3; // nondeterministic - string info = 4; // nondeterministic - int64 gas_wanted = 5 [json_name = "gas_wanted"]; - int64 gas_used = 6 [json_name = "gas_used"]; - repeated Event events = 7 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; - string codespace = 8; - string sender = 9; - int64 priority = 10; - string mempool_error = 11; + uint32 code = 1; + bytes data = 2; + string log = 3; // nondeterministic + string info = 4; // nondeterministic + int64 gas_wanted = 5 [json_name = "gas_wanted"]; + int64 gas_used = 6 [json_name = "gas_used"]; + repeated Event events = 7 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"]; + string codespace = 8; + string sender = 9; + int64 priority = 10; + + // mempool_error is set by Tendermint. + // ABCI applictions creating a ResponseCheckTX should not set mempool_error. + string mempool_error = 11; } message ResponseDeliverTx { From 9a3861fb8243edfd14648549f354c87e09b4c196 Mon Sep 17 00:00:00 2001 From: Callum Waters Date: Tue, 27 Jul 2021 18:59:34 +0200 Subject: [PATCH 09/35] light: wait for tendermint node to start before running example test (#6744) --- light/example_test.go | 103 ++++++++---------------------------------- light/light_test.go | 38 +++++++++++++--- 2 files changed, 51 insertions(+), 90 deletions(-) diff --git a/light/example_test.go b/light/example_test.go index 0fd6640c4..2e0feb5e1 100644 --- a/light/example_test.go +++ b/light/example_test.go @@ -2,7 +2,6 @@ package light_test import ( "context" - "fmt" "io/ioutil" stdlog "log" "os" @@ -19,87 +18,12 @@ import ( rpctest "github.com/tendermint/tendermint/rpc/test" ) -// Automatically getting new headers and verifying them. -func ExampleClient_Update() { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - conf := rpctest.CreateConfig("ExampleClient_Update") - - // Start a test application - app := kvstore.NewApplication() - _, closer, err := rpctest.StartTendermint(ctx, conf, app, rpctest.SuppressStdout) - if err != nil { - stdlog.Fatal(err) - } - defer func() { _ = closer(ctx) }() - - // give Tendermint time to generate some blocks - time.Sleep(5 * time.Second) - - dbDir, err := ioutil.TempDir("", "light-client-example") - if err != nil { - stdlog.Fatal(err) - } - defer os.RemoveAll(dbDir) - - chainID := conf.ChainID() - - primary, err := httpp.New(chainID, conf.RPC.ListenAddress) - if err != nil { - stdlog.Fatal(err) - } - - block, err := primary.LightBlock(ctx, 2) - if err != nil { - stdlog.Fatal(err) - } - - db, err := dbm.NewGoLevelDB("light-client-db", dbDir) - if err != nil { - stdlog.Fatal(err) - } - - c, err := light.NewClient( - ctx, - chainID, - light.TrustOptions{ - Period: 504 * time.Hour, // 21 days - Height: 2, - Hash: block.Hash(), - }, - primary, - []provider.Provider{primary}, // NOTE: primary should not be used here - dbs.New(db), - light.Logger(log.TestingLogger()), - ) - if err != nil { - stdlog.Fatal(err) - } - defer func() { - if err := c.Cleanup(); err != nil { - stdlog.Fatal(err) - } - }() - - time.Sleep(2 * time.Second) - - h, err := c.Update(ctx, time.Now()) - if err != nil { - stdlog.Fatal(err) - } - - if h != nil && h.Height > 2 { - fmt.Println("successful update") - } else { - fmt.Println("update failed") - } -} - // Manually getting light blocks and verifying them. -func ExampleClient_VerifyLightBlockAtHeight() { +func ExampleClient() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() conf := rpctest.CreateConfig("ExampleClient_VerifyLightBlockAtHeight") + logger := log.TestingLogger() // Start a test application app := kvstore.NewApplication() @@ -110,9 +34,6 @@ func ExampleClient_VerifyLightBlockAtHeight() { } defer func() { _ = closer(ctx) }() - // give Tendermint time to generate some blocks - time.Sleep(5 * time.Second) - dbDir, err := ioutil.TempDir("", "light-client-example") if err != nil { stdlog.Fatal(err) @@ -126,6 +47,9 @@ func ExampleClient_VerifyLightBlockAtHeight() { stdlog.Fatal(err) } + // give Tendermint time to generate some blocks + time.Sleep(5 * time.Second) + block, err := primary.LightBlock(ctx, 2) if err != nil { stdlog.Fatal(err) @@ -146,7 +70,7 @@ func ExampleClient_VerifyLightBlockAtHeight() { primary, []provider.Provider{primary}, // NOTE: primary should not be used here dbs.New(db), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) if err != nil { stdlog.Fatal(err) @@ -157,15 +81,26 @@ func ExampleClient_VerifyLightBlockAtHeight() { } }() + // wait for a few more blocks to be produced + time.Sleep(2 * time.Second) + + // veify the block at height 3 _, err = c.VerifyLightBlockAtHeight(context.Background(), 3, time.Now()) if err != nil { stdlog.Fatal(err) } - h, err := c.TrustedLightBlock(3) + // retrieve light block at height 3 + _, err = c.TrustedLightBlock(3) if err != nil { stdlog.Fatal(err) } - fmt.Println("got header", h.Height) + // update to the latest height + lb, err := c.Update(ctx, time.Now()) + if err != nil { + stdlog.Fatal(err) + } + + logger.Info("verified light block", "light-block", lb) } diff --git a/light/light_test.go b/light/light_test.go index a224d71b2..f5d2ddd89 100644 --- a/light/light_test.go +++ b/light/light_test.go @@ -17,6 +17,7 @@ import ( httpp "github.com/tendermint/tendermint/light/provider/http" dbs "github.com/tendermint/tendermint/light/store/db" rpctest "github.com/tendermint/tendermint/rpc/test" + "github.com/tendermint/tendermint/types" ) // NOTE: these are ports of the tests from example_test.go but @@ -48,7 +49,8 @@ func TestClientIntegration_Update(t *testing.T) { primary, err := httpp.New(chainID, conf.RPC.ListenAddress) require.NoError(t, err) - block, err := primary.LightBlock(ctx, 2) + // give Tendermint time to generate some blocks + block, err := waitForBlock(ctx, primary, 2) require.NoError(t, err) db, err := dbm.NewGoLevelDB("light-client-db", dbDir) @@ -71,7 +73,9 @@ func TestClientIntegration_Update(t *testing.T) { defer func() { require.NoError(t, c.Cleanup()) }() - time.Sleep(2 * time.Second) + // ensure Tendermint is at height 3 or higher + _, err = waitForBlock(ctx, primary, 3) + require.NoError(t, err) h, err := c.Update(ctx, time.Now()) require.NoError(t, err) @@ -94,9 +98,6 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) { require.NoError(t, err) defer func() { require.NoError(t, closer(ctx)) }() - // give Tendermint time to generate some blocks - time.Sleep(5 * time.Second) - dbDir, err := ioutil.TempDir("", "light-client-test-verify-example") require.NoError(t, err) defer os.RemoveAll(dbDir) @@ -106,7 +107,8 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) { primary, err := httpp.New(chainID, conf.RPC.ListenAddress) require.NoError(t, err) - block, err := primary.LightBlock(ctx, 2) + // give Tendermint time to generate some blocks + block, err := waitForBlock(ctx, primary, 2) require.NoError(t, err) db, err := dbm.NewGoLevelDB("light-client-db", dbDir) @@ -128,6 +130,10 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) { defer func() { require.NoError(t, c.Cleanup()) }() + // ensure Tendermint is at height 3 or higher + _, err = waitForBlock(ctx, primary, 3) + require.NoError(t, err) + _, err = c.VerifyLightBlockAtHeight(ctx, 3, time.Now()) require.NoError(t, err) @@ -136,3 +142,23 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) { require.EqualValues(t, 3, h.Height) } + +func waitForBlock(ctx context.Context, p provider.Provider, height int64) (*types.LightBlock, error) { + for { + block, err := p.LightBlock(ctx, height) + switch err { + case nil: + return block, nil + // node isn't running yet, wait 1 second and repeat + case provider.ErrNoResponse, provider.ErrHeightTooHigh: + timer := time.NewTimer(1 * time.Second) + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-timer.C: + } + default: + return nil, err + } + } +} From 4f73748bc805227872ef30ac569b872949aeb111 Mon Sep 17 00:00:00 2001 From: Aleksandr Bezobchuk Date: Tue, 27 Jul 2021 15:34:06 -0400 Subject: [PATCH 10/35] mempool v1: tweak broadcastTxRoutine (#6771) --- internal/mempool/v1/mempool.go | 4 ++-- internal/mempool/v1/reactor.go | 21 ++++++++------------- 2 files changed, 10 insertions(+), 15 deletions(-) diff --git a/internal/mempool/v1/mempool.go b/internal/mempool/v1/mempool.go index aab3020ef..850600697 100644 --- a/internal/mempool/v1/mempool.go +++ b/internal/mempool/v1/mempool.go @@ -188,8 +188,8 @@ func (txmp *TxMempool) WaitForNextTx() <-chan struct{} { // NextGossipTx returns the next valid transaction to gossip. A caller must wait // for WaitForNextTx to signal a transaction is available to gossip first. It is // thread-safe. -func (txmp *TxMempool) NextGossipTx() *WrappedTx { - return txmp.gossipIndex.Front().Value.(*WrappedTx) +func (txmp *TxMempool) NextGossipTx() *clist.CElement { + return txmp.gossipIndex.Front() } // EnableTxsAvailable enables the mempool to trigger events when transactions diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go index 436dd9d27..9deb7aace 100644 --- a/internal/mempool/v1/reactor.go +++ b/internal/mempool/v1/reactor.go @@ -9,6 +9,7 @@ import ( "time" cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/internal/libs/clist" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/internal/mempool" "github.com/tendermint/tendermint/internal/p2p" @@ -306,7 +307,7 @@ func (r *Reactor) processPeerUpdates() { func (r *Reactor) broadcastTxRoutine(peerID types.NodeID, closer *tmsync.Closer) { peerMempoolID := r.ids.GetForPeer(peerID) - var memTx *WrappedTx + var nextGossipTx *clist.CElement // remove the peer ID from the map of routines and mark the waitgroup as done defer func() { @@ -333,10 +334,10 @@ func (r *Reactor) broadcastTxRoutine(peerID types.NodeID, closer *tmsync.Closer) // This happens because the CElement we were looking at got garbage // collected (removed). That is, .NextWait() returned nil. Go ahead and // start from the beginning. - if memTx == nil { + if nextGossipTx == nil { select { case <-r.mempool.WaitForNextTx(): // wait until a tx is available - if memTx = r.mempool.NextGossipTx(); memTx == nil { + if nextGossipTx = r.mempool.NextGossipTx(); nextGossipTx == nil { continue } @@ -352,6 +353,8 @@ func (r *Reactor) broadcastTxRoutine(peerID types.NodeID, closer *tmsync.Closer) } } + memTx := nextGossipTx.Value.(*WrappedTx) + if r.peerMgr != nil { height := r.peerMgr.GetHeight(peerID) if height > 0 && height < memTx.height-1 { @@ -380,16 +383,8 @@ func (r *Reactor) broadcastTxRoutine(peerID types.NodeID, closer *tmsync.Closer) } select { - case <-memTx.gossipEl.NextWaitChan(): - // If there is a next element in gossip index, we point memTx to that node's - // value, otherwise we reset memTx to nil which will be checked at the - // parent for loop. - next := memTx.gossipEl.Next() - if next != nil { - memTx = next.Value.(*WrappedTx) - } else { - memTx = nil - } + case <-nextGossipTx.NextWaitChan(): + nextGossipTx = nextGossipTx.Next() case <-closer.Done(): // The peer is marked for removal via a PeerUpdate as the doneCh was From e87b0391cbbbffbe10f89601f53ef0032f33185c Mon Sep 17 00:00:00 2001 From: JayT106 Date: Tue, 27 Jul 2021 18:04:54 -0400 Subject: [PATCH 11/35] cli/indexer: Reindex events (#6676) --- CHANGELOG_PENDING.md | 1 + cmd/tendermint/commands/reindex_event.go | 251 ++++++++++++++++++ cmd/tendermint/commands/reindex_event_test.go | 171 ++++++++++++ cmd/tendermint/main.go | 1 + internal/libs/progressbar/progressbar.go | 41 +++ internal/libs/progressbar/progressbar_test.go | 41 +++ state/indexer/eventsink.go | 2 + state/mocks/block_store.go | 194 ++++++++++++++ state/mocks/event_sink.go | 167 ++++++++++++ state/services.go | 2 + 10 files changed, 871 insertions(+) create mode 100644 cmd/tendermint/commands/reindex_event.go create mode 100644 cmd/tendermint/commands/reindex_event_test.go create mode 100644 internal/libs/progressbar/progressbar.go create mode 100644 internal/libs/progressbar/progressbar_test.go create mode 100644 state/mocks/block_store.go create mode 100644 state/mocks/event_sink.go diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md index a800b8d33..45762880f 100644 --- a/CHANGELOG_PENDING.md +++ b/CHANGELOG_PENDING.md @@ -82,6 +82,7 @@ Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermi - Tooling - [tools] \#6498 Set OS home dir to instead of the hardcoded PATH. (@JayT106) + - [cli/indexer] \#6676 Reindex events command line tooling. (@JayT106) ### FEATURES diff --git a/cmd/tendermint/commands/reindex_event.go b/cmd/tendermint/commands/reindex_event.go new file mode 100644 index 000000000..ddc585c1f --- /dev/null +++ b/cmd/tendermint/commands/reindex_event.go @@ -0,0 +1,251 @@ +package commands + +import ( + "errors" + "fmt" + "strings" + + "github.com/spf13/cobra" + tmdb "github.com/tendermint/tm-db" + + abcitypes "github.com/tendermint/tendermint/abci/types" + tmcfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/internal/libs/progressbar" + ctypes "github.com/tendermint/tendermint/rpc/core/types" + "github.com/tendermint/tendermint/state" + "github.com/tendermint/tendermint/state/indexer" + "github.com/tendermint/tendermint/state/indexer/sink/kv" + "github.com/tendermint/tendermint/state/indexer/sink/psql" + "github.com/tendermint/tendermint/store" + "github.com/tendermint/tendermint/types" +) + +const ( + reindexFailed = "event re-index failed: " +) + +// ReIndexEventCmd allows re-index the event by given block height interval +var ReIndexEventCmd = &cobra.Command{ + Use: "reindex-event", + Short: "reindex events to the event store backends", + Long: ` + reindex-event is an offline tooling to re-index block and tx events to the eventsinks, + you can run this command when the event store backend dropped/disconnected or you want to replace the backend. + The default start-height is 0, meaning the tooling will start reindex from the base block height(inclusive); and the + default end-height is 0, meaning the tooling will reindex until the latest block height(inclusive). User can omits + either or both arguments. + `, + Example: ` + tendermint reindex-event + tendermint reindex-event --start-height 2 + tendermint reindex-event --end-height 10 + tendermint reindex-event --start-height 2 --end-height 10 + `, + Run: func(cmd *cobra.Command, args []string) { + bs, ss, err := loadStateAndBlockStore(config) + if err != nil { + fmt.Println(reindexFailed, err) + return + } + + if err := checkValidHeight(bs); err != nil { + fmt.Println(reindexFailed, err) + return + } + + es, err := loadEventSinks(config) + if err != nil { + fmt.Println(reindexFailed, err) + return + } + + if err = eventReIndex(cmd, es, bs, ss); err != nil { + fmt.Println(reindexFailed, err) + return + } + + fmt.Println("event re-index finished") + }, +} + +var ( + startHeight int64 + endHeight int64 +) + +func init() { + ReIndexEventCmd.Flags().Int64Var(&startHeight, "start-height", 0, "the block height would like to start for re-index") + ReIndexEventCmd.Flags().Int64Var(&endHeight, "end-height", 0, "the block height would like to finish for re-index") +} + +func loadEventSinks(cfg *tmcfg.Config) ([]indexer.EventSink, error) { + // Check duplicated sinks. + sinks := map[string]bool{} + for _, s := range cfg.TxIndex.Indexer { + sl := strings.ToLower(s) + if sinks[sl] { + return nil, errors.New("found duplicated sinks, please check the tx-index section in the config.toml") + } + sinks[sl] = true + } + + eventSinks := []indexer.EventSink{} + + for k := range sinks { + switch k { + case string(indexer.NULL): + return nil, errors.New("found null event sink, please check the tx-index section in the config.toml") + case string(indexer.KV): + store, err := tmcfg.DefaultDBProvider(&tmcfg.DBContext{ID: "tx_index", Config: cfg}) + if err != nil { + return nil, err + } + eventSinks = append(eventSinks, kv.NewEventSink(store)) + case string(indexer.PSQL): + conn := cfg.TxIndex.PsqlConn + if conn == "" { + return nil, errors.New("the psql connection settings cannot be empty") + } + es, _, err := psql.NewEventSink(conn, chainID) + if err != nil { + return nil, err + } + eventSinks = append(eventSinks, es) + default: + return nil, errors.New("unsupported event sink type") + } + } + + if len(eventSinks) == 0 { + return nil, errors.New("no proper event sink can do event re-indexing," + + " please check the tx-index section in the config.toml") + } + + if !indexer.IndexingEnabled(eventSinks) { + return nil, fmt.Errorf("no event sink has been enabled") + } + + return eventSinks, nil +} + +func loadStateAndBlockStore(cfg *tmcfg.Config) (*store.BlockStore, state.Store, error) { + dbType := tmdb.BackendType(cfg.DBBackend) + + // Get BlockStore + blockStoreDB, err := tmdb.NewDB("blockstore", dbType, cfg.DBDir()) + if err != nil { + return nil, nil, err + } + blockStore := store.NewBlockStore(blockStoreDB) + + // Get StateStore + stateDB, err := tmdb.NewDB("state", dbType, cfg.DBDir()) + if err != nil { + return nil, nil, err + } + stateStore := state.NewStore(stateDB) + + return blockStore, stateStore, nil +} + +func eventReIndex(cmd *cobra.Command, es []indexer.EventSink, bs state.BlockStore, ss state.Store) error { + + var bar progressbar.Bar + bar.NewOption(startHeight-1, endHeight) + + fmt.Println("start re-indexing events:") + defer bar.Finish() + for i := startHeight; i <= endHeight; i++ { + select { + case <-cmd.Context().Done(): + return fmt.Errorf("event re-index terminated at height %d: %w", i, cmd.Context().Err()) + default: + b := bs.LoadBlock(i) + if b == nil { + return fmt.Errorf("not able to load block at height %d from the blockstore", i) + } + + r, err := ss.LoadABCIResponses(i) + if err != nil { + return fmt.Errorf("not able to load ABCI Response at height %d from the statestore", i) + } + + e := types.EventDataNewBlockHeader{ + Header: b.Header, + NumTxs: int64(len(b.Txs)), + ResultBeginBlock: *r.BeginBlock, + ResultEndBlock: *r.EndBlock, + } + + var batch *indexer.Batch + if e.NumTxs > 0 { + batch = indexer.NewBatch(e.NumTxs) + + for i, tx := range b.Data.Txs { + tr := abcitypes.TxResult{ + Height: b.Height, + Index: uint32(i), + Tx: tx, + Result: *(r.DeliverTxs[i]), + } + + _ = batch.Add(&tr) + } + } + + for _, sink := range es { + if err := sink.IndexBlockEvents(e); err != nil { + return fmt.Errorf("block event re-index at height %d failed: %w", i, err) + } + + if batch != nil { + if err := sink.IndexTxEvents(batch.Ops); err != nil { + return fmt.Errorf("tx event re-index at height %d failed: %w", i, err) + } + } + } + } + + bar.Play(i) + } + + return nil +} + +func checkValidHeight(bs state.BlockStore) error { + base := bs.Base() + + if startHeight == 0 { + startHeight = base + fmt.Printf("set the start block height to the base height of the blockstore %d \n", base) + } + + if startHeight < base { + return fmt.Errorf("%s (requested start height: %d, base height: %d)", ctypes.ErrHeightNotAvailable, startHeight, base) + } + + height := bs.Height() + + if startHeight > height { + return fmt.Errorf( + "%s (requested start height: %d, store height: %d)", ctypes.ErrHeightNotAvailable, startHeight, height) + } + + if endHeight == 0 || endHeight > height { + endHeight = height + fmt.Printf("set the end block height to the latest height of the blockstore %d \n", height) + } + + if endHeight < base { + return fmt.Errorf( + "%s (requested end height: %d, base height: %d)", ctypes.ErrHeightNotAvailable, endHeight, base) + } + + if endHeight < startHeight { + return fmt.Errorf( + "%s (requested the end height: %d is less than the start height: %d)", + ctypes.ErrInvalidRequest, startHeight, endHeight) + } + + return nil +} diff --git a/cmd/tendermint/commands/reindex_event_test.go b/cmd/tendermint/commands/reindex_event_test.go new file mode 100644 index 000000000..5d9459f5a --- /dev/null +++ b/cmd/tendermint/commands/reindex_event_test.go @@ -0,0 +1,171 @@ +package commands + +import ( + "context" + "errors" + "testing" + + "github.com/spf13/cobra" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + + abcitypes "github.com/tendermint/tendermint/abci/types" + tmcfg "github.com/tendermint/tendermint/config" + prototmstate "github.com/tendermint/tendermint/proto/tendermint/state" + "github.com/tendermint/tendermint/state/indexer" + "github.com/tendermint/tendermint/state/mocks" + "github.com/tendermint/tendermint/types" +) + +const ( + height int64 = 10 + base int64 = 2 +) + +func setupReIndexEventCmd() *cobra.Command { + reIndexEventCmd := &cobra.Command{ + Use: ReIndexEventCmd.Use, + Run: func(cmd *cobra.Command, args []string) {}, + } + + _ = reIndexEventCmd.ExecuteContext(context.Background()) + + return reIndexEventCmd +} + +func TestReIndexEventCheckHeight(t *testing.T) { + mockBlockStore := &mocks.BlockStore{} + mockBlockStore. + On("Base").Return(base). + On("Height").Return(height) + + testCases := []struct { + startHeight int64 + endHeight int64 + validHeight bool + }{ + {0, 0, true}, + {0, base, true}, + {0, base - 1, false}, + {0, height, true}, + {0, height + 1, true}, + {0, 0, true}, + {base - 1, 0, false}, + {base, 0, true}, + {base, base, true}, + {base, base - 1, false}, + {base, height, true}, + {base, height + 1, true}, + {height, 0, true}, + {height, base, false}, + {height, height - 1, false}, + {height, height, true}, + {height, height + 1, true}, + {height + 1, 0, false}, + } + + for _, tc := range testCases { + startHeight = tc.startHeight + endHeight = tc.endHeight + + err := checkValidHeight(mockBlockStore) + if tc.validHeight { + require.NoError(t, err) + } else { + require.Error(t, err) + } + } +} + +func TestLoadEventSink(t *testing.T) { + testCases := []struct { + sinks []string + connURL string + loadErr bool + }{ + {[]string{}, "", true}, + {[]string{"NULL"}, "", true}, + {[]string{"KV"}, "", false}, + {[]string{"KV", "KV"}, "", true}, + {[]string{"PSQL"}, "", true}, // true because empty connect url + {[]string{"PSQL"}, "wrongUrl", true}, // true because wrong connect url + // skip to test PSQL connect with correct url + {[]string{"UnsupportedSinkType"}, "wrongUrl", true}, + } + + for _, tc := range testCases { + cfg := tmcfg.TestConfig() + cfg.TxIndex.Indexer = tc.sinks + cfg.TxIndex.PsqlConn = tc.connURL + _, err := loadEventSinks(cfg) + if tc.loadErr { + require.Error(t, err) + } else { + require.NoError(t, err) + } + } +} + +func TestLoadBlockStore(t *testing.T) { + bs, ss, err := loadStateAndBlockStore(tmcfg.TestConfig()) + require.NoError(t, err) + require.NotNil(t, bs) + require.NotNil(t, ss) + +} +func TestReIndexEvent(t *testing.T) { + mockBlockStore := &mocks.BlockStore{} + mockStateStore := &mocks.Store{} + mockEventSink := &mocks.EventSink{} + + mockBlockStore. + On("Base").Return(base). + On("Height").Return(height). + On("LoadBlock", base).Return(nil).Once(). + On("LoadBlock", base).Return(&types.Block{Data: types.Data{Txs: types.Txs{make(types.Tx, 1)}}}). + On("LoadBlock", height).Return(&types.Block{Data: types.Data{Txs: types.Txs{make(types.Tx, 1)}}}) + + mockEventSink. + On("Type").Return(indexer.KV). + On("IndexBlockEvents", mock.AnythingOfType("types.EventDataNewBlockHeader")).Return(errors.New("")).Once(). + On("IndexBlockEvents", mock.AnythingOfType("types.EventDataNewBlockHeader")).Return(nil). + On("IndexTxEvents", mock.AnythingOfType("[]*types.TxResult")).Return(errors.New("")).Once(). + On("IndexTxEvents", mock.AnythingOfType("[]*types.TxResult")).Return(nil) + + dtx := abcitypes.ResponseDeliverTx{} + abciResp := &prototmstate.ABCIResponses{ + DeliverTxs: []*abcitypes.ResponseDeliverTx{&dtx}, + EndBlock: &abcitypes.ResponseEndBlock{}, + BeginBlock: &abcitypes.ResponseBeginBlock{}, + } + + mockStateStore. + On("LoadABCIResponses", base).Return(nil, errors.New("")).Once(). + On("LoadABCIResponses", base).Return(abciResp, nil). + On("LoadABCIResponses", height).Return(abciResp, nil) + + testCases := []struct { + startHeight int64 + endHeight int64 + reIndexErr bool + }{ + {base, height, true}, // LoadBlock error + {base, height, true}, // LoadABCIResponses error + {base, height, true}, // index block event error + {base, height, true}, // index tx event error + {base, base, false}, + {height, height, false}, + } + + for _, tc := range testCases { + startHeight = tc.startHeight + endHeight = tc.endHeight + + err := eventReIndex(setupReIndexEventCmd(), []indexer.EventSink{mockEventSink}, mockBlockStore, mockStateStore) + if tc.reIndexErr { + require.Error(t, err) + } else { + require.NoError(t, err) + } + } +} diff --git a/cmd/tendermint/main.go b/cmd/tendermint/main.go index 52a26b4f3..b40624cc3 100644 --- a/cmd/tendermint/main.go +++ b/cmd/tendermint/main.go @@ -15,6 +15,7 @@ func main() { rootCmd := cmd.RootCmd rootCmd.AddCommand( cmd.GenValidatorCmd, + cmd.ReIndexEventCmd, cmd.InitFilesCmd, cmd.ProbeUpnpCmd, cmd.LightCmd, diff --git a/internal/libs/progressbar/progressbar.go b/internal/libs/progressbar/progressbar.go new file mode 100644 index 000000000..072804c76 --- /dev/null +++ b/internal/libs/progressbar/progressbar.go @@ -0,0 +1,41 @@ +package progressbar + +import "fmt" + +// the progressbar indicates the current status and progress would be desired. +// ref: https://www.pixelstech.net/article/1596946473-A-simple-example-on-implementing-progress-bar-in-GoLang + +type Bar struct { + percent int64 // progress percentage + cur int64 // current progress + start int64 // the init starting value for progress + total int64 // total value for progress + rate string // the actual progress bar to be printed + graph string // the fill value for progress bar +} + +func (bar *Bar) NewOption(start, total int64) { + bar.cur = start + bar.start = start + bar.total = total + bar.graph = "█" + bar.percent = bar.getPercent() +} + +func (bar *Bar) getPercent() int64 { + return int64(float32(bar.cur-bar.start) / float32(bar.total-bar.start) * 100) +} + +func (bar *Bar) Play(cur int64) { + bar.cur = cur + last := bar.percent + bar.percent = bar.getPercent() + if bar.percent != last && bar.percent%2 == 0 { + bar.rate += bar.graph + } + fmt.Printf("\r[%-50s]%3d%% %8d/%d", bar.rate, bar.percent, bar.cur, bar.total) +} + +func (bar *Bar) Finish() { + fmt.Println() +} diff --git a/internal/libs/progressbar/progressbar_test.go b/internal/libs/progressbar/progressbar_test.go new file mode 100644 index 000000000..d135748f6 --- /dev/null +++ b/internal/libs/progressbar/progressbar_test.go @@ -0,0 +1,41 @@ +package progressbar + +import ( + "testing" + "time" + + "github.com/stretchr/testify/require" +) + +func TestProgressBar(t *testing.T) { + zero := int64(0) + hundred := int64(100) + + var bar Bar + bar.NewOption(zero, hundred) + + require.Equal(t, zero, bar.start) + require.Equal(t, zero, bar.cur) + require.Equal(t, hundred, bar.total) + require.Equal(t, zero, bar.percent) + require.Equal(t, "█", bar.graph) + require.Equal(t, "", bar.rate) + + defer bar.Finish() + for i := zero; i <= hundred; i++ { + time.Sleep(1 * time.Millisecond) + bar.Play(i) + } + + require.Equal(t, zero, bar.start) + require.Equal(t, hundred, bar.cur) + require.Equal(t, hundred, bar.total) + require.Equal(t, hundred, bar.percent) + + var rate string + for i := zero; i < hundred/2; i++ { + rate += "█" + } + + require.Equal(t, rate, bar.rate) +} diff --git a/state/indexer/eventsink.go b/state/indexer/eventsink.go index 8c2529103..19d93e4e5 100644 --- a/state/indexer/eventsink.go +++ b/state/indexer/eventsink.go @@ -16,6 +16,8 @@ const ( PSQL EventSinkType = "psql" ) +//go:generate mockery --case underscore --name EventSink + // EventSink interface is defined the APIs for the IndexerService to interact with the data store, // including the block/transaction indexing and the search functions. // diff --git a/state/mocks/block_store.go b/state/mocks/block_store.go new file mode 100644 index 000000000..99cadd081 --- /dev/null +++ b/state/mocks/block_store.go @@ -0,0 +1,194 @@ +// Code generated by mockery 2.7.5. DO NOT EDIT. + +package mocks + +import ( + mock "github.com/stretchr/testify/mock" + + types "github.com/tendermint/tendermint/types" +) + +// BlockStore is an autogenerated mock type for the BlockStore type +type BlockStore struct { + mock.Mock +} + +// Base provides a mock function with given fields: +func (_m *BlockStore) Base() int64 { + ret := _m.Called() + + var r0 int64 + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + return r0 +} + +// Height provides a mock function with given fields: +func (_m *BlockStore) Height() int64 { + ret := _m.Called() + + var r0 int64 + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + return r0 +} + +// LoadBaseMeta provides a mock function with given fields: +func (_m *BlockStore) LoadBaseMeta() *types.BlockMeta { + ret := _m.Called() + + var r0 *types.BlockMeta + if rf, ok := ret.Get(0).(func() *types.BlockMeta); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.BlockMeta) + } + } + + return r0 +} + +// LoadBlock provides a mock function with given fields: height +func (_m *BlockStore) LoadBlock(height int64) *types.Block { + ret := _m.Called(height) + + var r0 *types.Block + if rf, ok := ret.Get(0).(func(int64) *types.Block); ok { + r0 = rf(height) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Block) + } + } + + return r0 +} + +// LoadBlockByHash provides a mock function with given fields: hash +func (_m *BlockStore) LoadBlockByHash(hash []byte) *types.Block { + ret := _m.Called(hash) + + var r0 *types.Block + if rf, ok := ret.Get(0).(func([]byte) *types.Block); ok { + r0 = rf(hash) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Block) + } + } + + return r0 +} + +// LoadBlockCommit provides a mock function with given fields: height +func (_m *BlockStore) LoadBlockCommit(height int64) *types.Commit { + ret := _m.Called(height) + + var r0 *types.Commit + if rf, ok := ret.Get(0).(func(int64) *types.Commit); ok { + r0 = rf(height) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Commit) + } + } + + return r0 +} + +// LoadBlockMeta provides a mock function with given fields: height +func (_m *BlockStore) LoadBlockMeta(height int64) *types.BlockMeta { + ret := _m.Called(height) + + var r0 *types.BlockMeta + if rf, ok := ret.Get(0).(func(int64) *types.BlockMeta); ok { + r0 = rf(height) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.BlockMeta) + } + } + + return r0 +} + +// LoadBlockPart provides a mock function with given fields: height, index +func (_m *BlockStore) LoadBlockPart(height int64, index int) *types.Part { + ret := _m.Called(height, index) + + var r0 *types.Part + if rf, ok := ret.Get(0).(func(int64, int) *types.Part); ok { + r0 = rf(height, index) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Part) + } + } + + return r0 +} + +// LoadSeenCommit provides a mock function with given fields: height +func (_m *BlockStore) LoadSeenCommit(height int64) *types.Commit { + ret := _m.Called(height) + + var r0 *types.Commit + if rf, ok := ret.Get(0).(func(int64) *types.Commit); ok { + r0 = rf(height) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.Commit) + } + } + + return r0 +} + +// PruneBlocks provides a mock function with given fields: height +func (_m *BlockStore) PruneBlocks(height int64) (uint64, error) { + ret := _m.Called(height) + + var r0 uint64 + if rf, ok := ret.Get(0).(func(int64) uint64); ok { + r0 = rf(height) + } else { + r0 = ret.Get(0).(uint64) + } + + var r1 error + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(height) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SaveBlock provides a mock function with given fields: block, blockParts, seenCommit +func (_m *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) { + _m.Called(block, blockParts, seenCommit) +} + +// Size provides a mock function with given fields: +func (_m *BlockStore) Size() int64 { + ret := _m.Called() + + var r0 int64 + if rf, ok := ret.Get(0).(func() int64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int64) + } + + return r0 +} \ No newline at end of file diff --git a/state/mocks/event_sink.go b/state/mocks/event_sink.go new file mode 100644 index 000000000..749515ccf --- /dev/null +++ b/state/mocks/event_sink.go @@ -0,0 +1,167 @@ +// Code generated by mockery 2.7.5. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + indexer "github.com/tendermint/tendermint/state/indexer" + + query "github.com/tendermint/tendermint/libs/pubsub/query" + + tenderminttypes "github.com/tendermint/tendermint/types" + + types "github.com/tendermint/tendermint/abci/types" +) + +// EventSink is an autogenerated mock type for the EventSink type +type EventSink struct { + mock.Mock +} + +// GetTxByHash provides a mock function with given fields: _a0 +func (_m *EventSink) GetTxByHash(_a0 []byte) (*types.TxResult, error) { + ret := _m.Called(_a0) + + var r0 *types.TxResult + if rf, ok := ret.Get(0).(func([]byte) *types.TxResult); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.TxResult) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func([]byte) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// HasBlock provides a mock function with given fields: _a0 +func (_m *EventSink) HasBlock(_a0 int64) (bool, error) { + ret := _m.Called(_a0) + + var r0 bool + if rf, ok := ret.Get(0).(func(int64) bool); ok { + r0 = rf(_a0) + } else { + r0 = ret.Get(0).(bool) + } + + var r1 error + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IndexBlockEvents provides a mock function with given fields: _a0 +func (_m *EventSink) IndexBlockEvents(_a0 tenderminttypes.EventDataNewBlockHeader) error { + ret := _m.Called(_a0) + + var r0 error + if rf, ok := ret.Get(0).(func(tenderminttypes.EventDataNewBlockHeader) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// IndexTxEvents provides a mock function with given fields: _a0 +func (_m *EventSink) IndexTxEvents(_a0 []*types.TxResult) error { + ret := _m.Called(_a0) + + var r0 error + if rf, ok := ret.Get(0).(func([]*types.TxResult) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SearchBlockEvents provides a mock function with given fields: _a0, _a1 +func (_m *EventSink) SearchBlockEvents(_a0 context.Context, _a1 *query.Query) ([]int64, error) { + ret := _m.Called(_a0, _a1) + + var r0 []int64 + if rf, ok := ret.Get(0).(func(context.Context, *query.Query) []int64); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]int64) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *query.Query) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SearchTxEvents provides a mock function with given fields: _a0, _a1 +func (_m *EventSink) SearchTxEvents(_a0 context.Context, _a1 *query.Query) ([]*types.TxResult, error) { + ret := _m.Called(_a0, _a1) + + var r0 []*types.TxResult + if rf, ok := ret.Get(0).(func(context.Context, *query.Query) []*types.TxResult); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*types.TxResult) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *query.Query) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stop provides a mock function with given fields: +func (_m *EventSink) Stop() error { + ret := _m.Called() + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Type provides a mock function with given fields: +func (_m *EventSink) Type() indexer.EventSinkType { + ret := _m.Called() + + var r0 indexer.EventSinkType + if rf, ok := ret.Get(0).(func() indexer.EventSinkType); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(indexer.EventSinkType) + } + + return r0 +} diff --git a/state/services.go b/state/services.go index a46863904..0ab6b78d0 100644 --- a/state/services.go +++ b/state/services.go @@ -9,6 +9,8 @@ import ( // NOTE: Interfaces used by RPC must be thread safe! //------------------------------------------------------ +//go:generate mockery --case underscore --name BlockStore + //------------------------------------------------------ // blockstore From 6ff4c3139cd323a48f8fa1b16f5c229ce1b48ae7 Mon Sep 17 00:00:00 2001 From: Callum Waters Date: Wed, 28 Jul 2021 17:25:42 +0200 Subject: [PATCH 12/35] blockchain: rename to blocksync service (#6755) --- CHANGELOG_PENDING.md | 2 + UPGRADING.md | 7 +- config/config.go | 44 +++++----- config/config_test.go | 4 +- config/toml.go | 8 +- docs/nodes/configuration.md | 8 +- docs/tendermint-core/README.md | 2 +- .../{fast-sync.md => block-sync.md} | 23 +++--- docs/tendermint-core/state-sync.md | 2 +- internal/{blockchain => blocksync}/doc.go | 20 ++--- internal/{blockchain => blocksync}/msgs.go | 4 +- internal/{blockchain => blocksync}/v0/pool.go | 2 +- .../{blockchain => blocksync}/v0/pool_test.go | 0 .../{blockchain => blocksync}/v0/reactor.go | 32 ++++---- .../v0/reactor_test.go | 8 +- .../v2/internal/behavior/doc.go | 0 .../v2/internal/behavior/peer_behaviour.go | 0 .../v2/internal/behavior/reporter.go | 0 .../v2/internal/behavior/reporter_test.go | 2 +- internal/{blockchain => blocksync}/v2/io.go | 4 +- .../{blockchain => blocksync}/v2/metrics.go | 0 .../{blockchain => blocksync}/v2/processor.go | 0 .../v2/processor_context.go | 0 .../v2/processor_test.go | 0 .../{blockchain => blocksync}/v2/reactor.go | 46 +++++------ .../v2/reactor_test.go | 4 +- .../{blockchain => blocksync}/v2/routine.go | 0 .../v2/routine_test.go | 0 .../{blockchain => blocksync}/v2/scheduler.go | 2 +- .../v2/scheduler_test.go | 0 .../{blockchain => blocksync}/v2/types.go | 0 internal/consensus/metrics.go | 12 +-- internal/consensus/mocks/cons_sync_reactor.go | 4 +- internal/consensus/mocks/fast_sync_reactor.go | 14 ++-- internal/consensus/reactor.go | 34 ++++---- internal/consensus/reactor_test.go | 24 +++--- node/node.go | 50 ++++++------ node/node_test.go | 2 +- node/setup.go | 26 +++--- .../{blockchain => blocksync}/message.go | 2 +- .../{blockchain => blocksync}/message_test.go | 4 +- .../{blockchain => blocksync}/types.pb.go | 81 +++++++++---------- .../{blockchain => blocksync}/types.proto | 4 +- rpc/core/env.go | 2 +- rpc/core/status.go | 6 +- test/e2e/README.md | 2 +- test/e2e/generator/generate.go | 6 +- test/e2e/networks/ci.toml | 23 ++---- test/e2e/pkg/manifest.go | 4 +- test/e2e/pkg/testnet.go | 8 +- test/e2e/runner/setup.go | 4 +- types/event_bus.go | 6 +- types/event_bus_test.go | 8 +- types/events.go | 14 ++-- 54 files changed, 278 insertions(+), 286 deletions(-) rename docs/tendermint-core/{fast-sync.md => block-sync.md} (79%) rename internal/{blockchain => blocksync}/doc.go (73%) rename internal/{blockchain => blocksync}/msgs.go (90%) rename internal/{blockchain => blocksync}/v0/pool.go (99%) rename internal/{blockchain => blocksync}/v0/pool_test.go (100%) rename internal/{blockchain => blocksync}/v0/reactor.go (96%) rename internal/{blockchain => blocksync}/v0/reactor_test.go (99%) rename internal/{blockchain => blocksync}/v2/internal/behavior/doc.go (100%) rename internal/{blockchain => blocksync}/v2/internal/behavior/peer_behaviour.go (100%) rename internal/{blockchain => blocksync}/v2/internal/behavior/reporter.go (100%) rename internal/{blockchain => blocksync}/v2/internal/behavior/reporter_test.go (98%) rename internal/{blockchain => blocksync}/v2/io.go (98%) rename internal/{blockchain => blocksync}/v2/metrics.go (100%) rename internal/{blockchain => blocksync}/v2/processor.go (100%) rename internal/{blockchain => blocksync}/v2/processor_context.go (100%) rename internal/{blockchain => blocksync}/v2/processor_test.go (100%) rename internal/{blockchain => blocksync}/v2/reactor.go (92%) rename internal/{blockchain => blocksync}/v2/reactor_test.go (99%) rename internal/{blockchain => blocksync}/v2/routine.go (100%) rename internal/{blockchain => blocksync}/v2/routine_test.go (100%) rename internal/{blockchain => blocksync}/v2/scheduler.go (99%) rename internal/{blockchain => blocksync}/v2/scheduler_test.go (100%) rename internal/{blockchain => blocksync}/v2/types.go (100%) rename proto/tendermint/{blockchain => blocksync}/message.go (99%) rename proto/tendermint/{blockchain => blocksync}/message_test.go (99%) 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 45762880f..de3a18ab6 100644 --- a/CHANGELOG_PENDING.md +++ b/CHANGELOG_PENDING.md @@ -72,6 +72,8 @@ Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermi - [crypto/sr25519] \#6526 Do not re-execute the Ed25519-style key derivation step when doing signing and verification. The derivation is now done once and only once. This breaks `sr25519.GenPrivKeyFromSecret` output compatibility. (@Yawning) - [types] \#6627 Move `NodeKey` to types to make the type public. - [config] \#6627 Extend `config` to contain methods `LoadNodeKeyID` and `LoadorGenNodeKeyID` + - [blocksync] \#6755 Rename `FastSync` and `Blockchain` package to `BlockSync` + (@cmwaters) - Blockchain Protocol diff --git a/UPGRADING.md b/UPGRADING.md index 6687f8e77..cc721af8e 100644 --- a/UPGRADING.md +++ b/UPGRADING.md @@ -17,7 +17,7 @@ This guide provides instructions for upgrading to specific versions of Tendermin ### Config Changes -* `fast_sync = "v1"` is no longer supported. Please use `v2` instead. +* `fast_sync = "v1"` and `fast_sync = "v2"` are no longer supported. Please use `v0` instead. * All config parameters are now hyphen-case (also known as kebab-case) instead of snake_case. Before restarting the node make sure you have updated all the variables in your `config.toml` file. @@ -29,10 +29,11 @@ This guide provides instructions for upgrading to specific versions of Tendermin `Seeds`. Bootstrap peers are connected with on startup if needed for peer discovery. Unlike persistent peers, there's no gaurantee that the node will remain connected with these peers. -- configuration values starting with `priv-validator-` have moved to the new +* configuration values starting with `priv-validator-` have moved to the new `priv-validator` section, without the `priv-validator-` prefix. -* Fast Sync v2 has been deprecated, please use v0 to sync a node. +* The fast sync process as well as the blockchain package and service has all + been renamed to block sync ### CLI Changes diff --git a/config/config.go b/config/config.go index 99b82fb46..7d19616aa 100644 --- a/config/config.go +++ b/config/config.go @@ -29,8 +29,8 @@ const ( ModeValidator = "validator" ModeSeed = "seed" - BlockchainV0 = "v0" - BlockchainV2 = "v2" + BlockSyncV0 = "v0" + BlockSyncV2 = "v2" MempoolV0 = "v0" MempoolV1 = "v1" @@ -76,7 +76,7 @@ type Config struct { P2P *P2PConfig `mapstructure:"p2p"` Mempool *MempoolConfig `mapstructure:"mempool"` StateSync *StateSyncConfig `mapstructure:"statesync"` - FastSync *FastSyncConfig `mapstructure:"fastsync"` + BlockSync *BlockSyncConfig `mapstructure:"fastsync"` Consensus *ConsensusConfig `mapstructure:"consensus"` TxIndex *TxIndexConfig `mapstructure:"tx-index"` Instrumentation *InstrumentationConfig `mapstructure:"instrumentation"` @@ -91,7 +91,7 @@ func DefaultConfig() *Config { P2P: DefaultP2PConfig(), Mempool: DefaultMempoolConfig(), StateSync: DefaultStateSyncConfig(), - FastSync: DefaultFastSyncConfig(), + BlockSync: DefaultBlockSyncConfig(), Consensus: DefaultConsensusConfig(), TxIndex: DefaultTxIndexConfig(), Instrumentation: DefaultInstrumentationConfig(), @@ -114,7 +114,7 @@ func TestConfig() *Config { P2P: TestP2PConfig(), Mempool: TestMempoolConfig(), StateSync: TestStateSyncConfig(), - FastSync: TestFastSyncConfig(), + BlockSync: TestBlockSyncConfig(), Consensus: TestConsensusConfig(), TxIndex: TestTxIndexConfig(), Instrumentation: TestInstrumentationConfig(), @@ -151,7 +151,7 @@ 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 { + if err := cfg.BlockSync.ValidateBasic(); err != nil { return fmt.Errorf("error in [fastsync] section: %w", err) } if err := cfg.Consensus.ValidateBasic(); err != nil { @@ -197,6 +197,7 @@ type BaseConfig struct { //nolint: maligned // If this node is many blocks behind the tip of the chain, FastSync // allows them to catchup quickly by downloading blocks in parallel // and verifying their commits + // TODO: This should be moved to the blocksync config FastSyncMode bool `mapstructure:"fast-sync"` // Database backend: goleveldb | cleveldb | boltdb | rocksdb @@ -911,7 +912,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() } @@ -967,34 +968,33 @@ func (cfg *StateSyncConfig) ValidateBasic() error { } //----------------------------------------------------------------------------- -// FastSyncConfig -// 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{ - Version: BlockchainV0, +// DefaultBlockSyncConfig returns a default configuration for the block sync service +func DefaultBlockSyncConfig() *BlockSyncConfig { + return &BlockSyncConfig{ + Version: BlockSyncV0, } } -// 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 BlockchainV0: + case BlockSyncV0: return nil - case BlockchainV2: - return errors.New("fastsync version v2 is no longer supported. Please use v0") + case BlockSyncV2: + return errors.New("blocksync version v2 is no longer supported. Please use v0") 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 9801b75cd..075cedc6a 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -125,8 +125,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 aae716a58..edb192109 100644 --- a/config/toml.go +++ b/config/toml.go @@ -452,14 +452,14 @@ chunk-request-timeout = "{{ .StateSync.ChunkRequestTimeout }}" fetchers = "{{ .StateSync.Fetchers }}" ####################################################### -### Fast Sync Configuration Connections ### +### Block Sync Configuration Connections ### ####################################################### [fastsync] -# Fast Sync version to use: -# 1) "v0" (default) - the legacy fast sync implementation +# Block Sync version to use: +# 1) "v0" (default) - the legacy block sync implementation # 2) "v2" - DEPRECATED, please use v0 -version = "{{ .FastSync.Version }}" +version = "{{ .BlockSync.Version }}" ####################################################### ### Consensus Configuration Options ### diff --git a/docs/nodes/configuration.md b/docs/nodes/configuration.md index 6e2665b26..b5259f93f 100644 --- a/docs/nodes/configuration.md +++ b/docs/nodes/configuration.md @@ -36,7 +36,7 @@ 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 @@ -354,12 +354,12 @@ discovery-time = "15s" temp-dir = "" ####################################################### -### Fast Sync Configuration Connections ### +### BlockSync Configuration Connections ### ####################################################### [fastsync] -# Fast Sync version to use: -# 1) "v0" (default) - the legacy fast sync implementation +# Block Sync version to use: +# 1) "v0" (default) - the legacy block sync implementation # 2) "v2" - complete redesign of v0, optimized for testability & readability version = "v0" diff --git a/docs/tendermint-core/README.md b/docs/tendermint-core/README.md index 666eff16d..fb359a08b 100644 --- a/docs/tendermint-core/README.md +++ b/docs/tendermint-core/README.md @@ -14,7 +14,7 @@ This section dives into the internals of Go-Tendermint. - [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 79% rename from docs/tendermint-core/fast-sync.md rename to docs/tendermint-core/block-sync.md index afc668277..9d362424f 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,7 +15,7 @@ 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 is enabled by default, and can be toggled in the `config.toml` or via @@ -22,36 +23,36 @@ is enabled by default, and can be toggled in the `config.toml` or via 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 v2 is still in beta. +Note: There are two versions of Block Sync. We recommend using v0 as v2 is still in beta. If you would like to use a different version you can do so by changing the version in the `config.toml`: ```toml ####################################################### -### Fast Sync Configuration Connections ### +### Block Sync Configuration Connections ### ####################################################### [fastsync] -# Fast Sync version to use: -# 1) "v0" (default) - the legacy fast sync implementation +# Block Sync version to use: +# 1) "v0" (default) - the legacy Block Sync implementation # 2) "v2" - complete redesign of v0, optimized for testability & readability 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). -## The Fast Sync event -When the tendermint blockchain core launches, it might switch to the `fast-sync` +## The Block Sync event +When the tendermint blockchain core launches, it might switch to the `block-sync` mode to catch up the states to the current network best height. the core will emits a fast-sync event to expose the current status and the sync height. Once it catched the network best height, it will switches to the state sync mechanism and then emit another event for exposing the fast-sync `complete` status and the state `height`. -The user can query the events by subscribing `EventQueryFastSyncStatus` +The user can query the events by subscribing `EventQueryBlockSyncStatus` Please check [types](https://pkg.go.dev/github.com/tendermint/tendermint/types?utm_source=godoc#pkg-constants) for the details. \ No newline at end of file diff --git a/docs/tendermint-core/state-sync.md b/docs/tendermint-core/state-sync.md index 623de4953..52286e6c7 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/internal/blockchain/doc.go b/internal/blocksync/doc.go similarity index 73% rename from internal/blockchain/doc.go rename to internal/blocksync/doc.go index f1db243c6..3111130e4 100644 --- a/internal/blockchain/doc.go +++ b/internal/blocksync/doc.go @@ -1,19 +1,19 @@ /* -Package blockchain implements two versions of a reactor Service that are -responsible for block propagation and gossip between peers. This mechanism is -more formally known as fast-sync. +Package blocksync implements two versions of a reactor Service that are +responsible for block propagation and gossip between peers. This mechanism was +formerly known as fast-sync. In order for a full node to successfully participate in consensus, it must have -the latest view of state. The fast-sync protocol is a mechanism in which peers +the latest view of state. The blocksync protocol is a mechanism in which peers may exchange and gossip entire blocks with one another, in a request/response type model, until they've successfully synced to the latest head block. Once succussfully synced, the full node can switch to an active role in consensus and -will no longer fast-sync and thus no longer run the fast-sync process. +will no longer blocksync and thus no longer run the blocksync process. -Note, the blockchain reactor Service gossips entire block and relevant data such -that each receiving peer may construct the entire view of the blockchain state. +Note, the blocksync reactor Service gossips entire block and relevant data such +that each receiving peer may construct the entire view of the blocksync state. -There are two versions of the blockchain reactor Service, i.e. fast-sync: +There are currently two versions of the blocksync reactor Service: - v0: The initial implementation that is battle-tested, but whose test coverage is lacking and is not formally verifiable. @@ -22,7 +22,7 @@ There are two versions of the blockchain reactor Service, i.e. fast-sync: is known to have various bugs that could make it unreliable in production environments. -The v0 blockchain reactor Service has one p2p channel, BlockchainChannel. This +The v0 blocksync reactor Service has one p2p channel, BlockchainChannel. This channel is responsible for handling messages that both request blocks and respond to block requests from peers. For every block request from a peer, the reactor will execute respondToPeer which will fetch the block from the node's state store @@ -33,4 +33,4 @@ Internally, v0 runs a poolRoutine that constantly checks for what blocks it need and requests them. The poolRoutine is also responsible for taking blocks from the pool, saving and executing each block. */ -package blockchain +package blocksync diff --git a/internal/blockchain/msgs.go b/internal/blocksync/msgs.go similarity index 90% rename from internal/blockchain/msgs.go rename to internal/blocksync/msgs.go index e901ae1e3..caad44b7b 100644 --- a/internal/blockchain/msgs.go +++ b/internal/blocksync/msgs.go @@ -1,7 +1,7 @@ -package blockchain +package blocksync import ( - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/types" ) diff --git a/internal/blockchain/v0/pool.go b/internal/blocksync/v0/pool.go similarity index 99% rename from internal/blockchain/v0/pool.go rename to internal/blocksync/v0/pool.go index c9c4030a8..b3704f333 100644 --- a/internal/blockchain/v0/pool.go +++ b/internal/blocksync/v0/pool.go @@ -65,7 +65,7 @@ type BlockRequest struct { PeerID types.NodeID } -// 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 lastAdvance time.Time diff --git a/internal/blockchain/v0/pool_test.go b/internal/blocksync/v0/pool_test.go similarity index 100% rename from internal/blockchain/v0/pool_test.go rename to internal/blocksync/v0/pool_test.go diff --git a/internal/blockchain/v0/reactor.go b/internal/blocksync/v0/reactor.go similarity index 96% rename from internal/blockchain/v0/reactor.go rename to internal/blocksync/v0/reactor.go index 52a17b693..c43959808 100644 --- a/internal/blockchain/v0/reactor.go +++ b/internal/blocksync/v0/reactor.go @@ -6,13 +6,13 @@ import ( "sync" "time" - bc "github.com/tendermint/tendermint/internal/blockchain" + bc "github.com/tendermint/tendermint/internal/blocksync" cons "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/service" tmSync "github.com/tendermint/tendermint/libs/sync" - 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" @@ -60,7 +60,7 @@ const ( ) type consensusReactor interface { - // For when we switch from blockchain reactor and fast sync to the consensus + // For when we switch from blockchain reactor and block sync to the consensus // machine. SwitchToConsensus(state sm.State, skipWAL bool) } @@ -85,7 +85,7 @@ type Reactor struct { store *store.BlockStore pool *BlockPool consReactor consensusReactor - fastSync *tmSync.AtomicBool + blockSync *tmSync.AtomicBool blockchainCh *p2p.Channel // blockchainOutBridgeCh defines a channel that acts as a bridge between sending Envelope @@ -121,7 +121,7 @@ func NewReactor( consReactor consensusReactor, blockchainCh *p2p.Channel, peerUpdates *p2p.PeerUpdates, - fastSync bool, + blockSync bool, metrics *cons.Metrics, ) (*Reactor, error) { if state.LastBlockHeight != store.Height() { @@ -142,7 +142,7 @@ func NewReactor( store: store, pool: NewBlockPool(startHeight, requestsCh, errorsCh), consReactor: consReactor, - fastSync: tmSync.NewBool(fastSync), + blockSync: tmSync.NewBool(blockSync), requestsCh: requestsCh, errorsCh: errorsCh, blockchainCh: blockchainCh, @@ -162,10 +162,10 @@ func NewReactor( // messages on that p2p channel accordingly. The caller must be sure to execute // OnStop to ensure the outbound p2p Channels are closed. // -// If fastSync is enabled, we also start the pool and the pool processing +// If blockSync is enabled, we also start the pool and the pool processing // goroutine. If the pool fails to start, an error is returned. func (r *Reactor) OnStart() error { - if r.fastSync.IsSet() { + if r.blockSync.IsSet() { if err := r.pool.Start(); err != nil { return err } @@ -183,7 +183,7 @@ func (r *Reactor) OnStart() error { // OnStop stops the reactor by signaling to all spawned goroutines to exit and // blocking until they all exit. func (r *Reactor) OnStop() { - if r.fastSync.IsSet() { + if r.blockSync.IsSet() { if err := r.pool.Stop(); err != nil { r.Logger.Error("failed to stop pool", "err", err) } @@ -371,10 +371,10 @@ func (r *Reactor) processPeerUpdates() { } } -// SwitchToFastSync is called by the state sync reactor when switching to fast +// SwitchToBlockSync is called by the state sync reactor when switching to fast // sync. -func (r *Reactor) SwitchToFastSync(state sm.State) error { - r.fastSync.Set() +func (r *Reactor) SwitchToBlockSync(state sm.State) error { + r.blockSync.Set() r.initialState = state r.pool.height = state.LastBlockHeight + 1 @@ -496,7 +496,7 @@ FOR_LOOP: r.Logger.Error("failed to stop pool", "err", err) } - r.fastSync.UnSet() + r.blockSync.UnSet() if r.consReactor != nil { r.consReactor.SwitchToConsensus(state, blocksSynced > 0 || stateSynced) @@ -591,7 +591,7 @@ FOR_LOOP: if blocksSynced%100 == 0 { lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds()) r.Logger.Info( - "fast sync rate", + "block sync rate", "height", r.pool.height, "max_peer_height", r.pool.MaxPeerHeight(), "blocks/s", lastRate, @@ -614,14 +614,14 @@ func (r *Reactor) GetMaxPeerBlockHeight() int64 { } func (r *Reactor) GetTotalSyncedTime() time.Duration { - if !r.fastSync.IsSet() || r.syncStartTime.IsZero() { + if !r.blockSync.IsSet() || r.syncStartTime.IsZero() { return time.Duration(0) } return time.Since(r.syncStartTime) } func (r *Reactor) GetRemainingSyncTime() time.Duration { - if !r.fastSync.IsSet() { + if !r.blockSync.IsSet() { return time.Duration(0) } diff --git a/internal/blockchain/v0/reactor_test.go b/internal/blocksync/v0/reactor_test.go similarity index 99% rename from internal/blockchain/v0/reactor_test.go rename to internal/blocksync/v0/reactor_test.go index 1c9dc60c4..e038b57af 100644 --- a/internal/blockchain/v0/reactor_test.go +++ b/internal/blocksync/v0/reactor_test.go @@ -15,7 +15,7 @@ import ( "github.com/tendermint/tendermint/internal/p2p/p2ptest" "github.com/tendermint/tendermint/internal/test/factory" "github.com/tendermint/tendermint/libs/log" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/proxy" sm "github.com/tendermint/tendermint/state" sf "github.com/tendermint/tendermint/state/test/factory" @@ -36,7 +36,7 @@ type reactorTestSuite struct { peerChans map[types.NodeID]chan p2p.PeerUpdate peerUpdates map[types.NodeID]*p2p.PeerUpdates - fastSync bool + blockSync bool } func setup( @@ -61,7 +61,7 @@ func setup( blockchainChannels: make(map[types.NodeID]*p2p.Channel, numNodes), peerChans: make(map[types.NodeID]chan p2p.PeerUpdate, numNodes), peerUpdates: make(map[types.NodeID]*p2p.PeerUpdates, numNodes), - fastSync: true, + blockSync: true, } chDesc := p2p.ChannelDescriptor{ID: byte(BlockchainChannel)} @@ -163,7 +163,7 @@ func (rts *reactorTestSuite) addNode(t *testing.T, nil, rts.blockchainChannels[nodeID], rts.peerUpdates[nodeID], - rts.fastSync, + rts.blockSync, cons.NopMetrics()) require.NoError(t, err) diff --git a/internal/blockchain/v2/internal/behavior/doc.go b/internal/blocksync/v2/internal/behavior/doc.go similarity index 100% rename from internal/blockchain/v2/internal/behavior/doc.go rename to internal/blocksync/v2/internal/behavior/doc.go diff --git a/internal/blockchain/v2/internal/behavior/peer_behaviour.go b/internal/blocksync/v2/internal/behavior/peer_behaviour.go similarity index 100% rename from internal/blockchain/v2/internal/behavior/peer_behaviour.go rename to internal/blocksync/v2/internal/behavior/peer_behaviour.go diff --git a/internal/blockchain/v2/internal/behavior/reporter.go b/internal/blocksync/v2/internal/behavior/reporter.go similarity index 100% rename from internal/blockchain/v2/internal/behavior/reporter.go rename to internal/blocksync/v2/internal/behavior/reporter.go diff --git a/internal/blockchain/v2/internal/behavior/reporter_test.go b/internal/blocksync/v2/internal/behavior/reporter_test.go similarity index 98% rename from internal/blockchain/v2/internal/behavior/reporter_test.go rename to internal/blocksync/v2/internal/behavior/reporter_test.go index a045f19aa..861a63df0 100644 --- a/internal/blockchain/v2/internal/behavior/reporter_test.go +++ b/internal/blocksync/v2/internal/behavior/reporter_test.go @@ -4,7 +4,7 @@ import ( "sync" "testing" - bh "github.com/tendermint/tendermint/internal/blockchain/v2/internal/behavior" + bh "github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior" "github.com/tendermint/tendermint/types" ) diff --git a/internal/blockchain/v2/io.go b/internal/blocksync/v2/io.go similarity index 98% rename from internal/blockchain/v2/io.go rename to internal/blocksync/v2/io.go index 8d02c408e..743428516 100644 --- a/internal/blockchain/v2/io.go +++ b/internal/blocksync/v2/io.go @@ -5,7 +5,7 @@ import ( "github.com/gogo/protobuf/proto" "github.com/tendermint/tendermint/internal/p2p" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/state" "github.com/tendermint/tendermint/types" ) @@ -42,7 +42,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 state.State, skipWAL bool) } diff --git a/internal/blockchain/v2/metrics.go b/internal/blocksync/v2/metrics.go similarity index 100% rename from internal/blockchain/v2/metrics.go rename to internal/blocksync/v2/metrics.go diff --git a/internal/blockchain/v2/processor.go b/internal/blocksync/v2/processor.go similarity index 100% rename from internal/blockchain/v2/processor.go rename to internal/blocksync/v2/processor.go diff --git a/internal/blockchain/v2/processor_context.go b/internal/blocksync/v2/processor_context.go similarity index 100% rename from internal/blockchain/v2/processor_context.go rename to internal/blocksync/v2/processor_context.go diff --git a/internal/blockchain/v2/processor_test.go b/internal/blocksync/v2/processor_test.go similarity index 100% rename from internal/blockchain/v2/processor_test.go rename to internal/blocksync/v2/processor_test.go diff --git a/internal/blockchain/v2/reactor.go b/internal/blocksync/v2/reactor.go similarity index 92% rename from internal/blockchain/v2/reactor.go rename to internal/blocksync/v2/reactor.go index af18f3c0a..caa5d73f0 100644 --- a/internal/blockchain/v2/reactor.go +++ b/internal/blocksync/v2/reactor.go @@ -7,14 +7,14 @@ import ( proto "github.com/gogo/protobuf/proto" - bc "github.com/tendermint/tendermint/internal/blockchain" - "github.com/tendermint/tendermint/internal/blockchain/v2/internal/behavior" + bc "github.com/tendermint/tendermint/internal/blocksync" + "github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior" cons "github.com/tendermint/tendermint/internal/consensus" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/sync" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/state" "github.com/tendermint/tendermint/types" ) @@ -31,12 +31,12 @@ type blockStore interface { Height() int64 } -// BlockchainReactor handles fast sync protocol. +// BlockchainReactor handles block sync protocol. type BlockchainReactor struct { p2p.BaseReactor - fastSync *sync.AtomicBool // enable fast sync on start when it's been Set - stateSynced bool // set to true when SwitchToFastSync is called by state sync + blockSync *sync.AtomicBool // enable block sync on start when it's been Set + stateSynced bool // set to true when SwitchToBlockSync is called by state sync scheduler *Routine processor *Routine logger log.Logger @@ -44,7 +44,7 @@ type BlockchainReactor struct { mtx tmsync.RWMutex maxPeerHeight int64 syncHeight int64 - events chan Event // non-nil during a fast sync + events chan Event // non-nil during a block sync reporter behavior.Reporter io iIO @@ -61,7 +61,7 @@ type blockApplier interface { // XXX: unify naming in this package around tmState func newReactor(state state.State, store blockStore, reporter behavior.Reporter, - blockApplier blockApplier, fastSync bool, metrics *cons.Metrics) *BlockchainReactor { + blockApplier blockApplier, blockSync bool, metrics *cons.Metrics) *BlockchainReactor { initHeight := state.LastBlockHeight + 1 if initHeight == 1 { initHeight = state.InitialHeight @@ -78,7 +78,7 @@ func newReactor(state state.State, store blockStore, reporter behavior.Reporter, store: store, reporter: reporter, logger: log.NewNopLogger(), - fastSync: sync.NewBool(fastSync), + blockSync: sync.NewBool(blockSync), syncStartHeight: initHeight, syncStartTime: time.Time{}, lastSyncRate: 0, @@ -90,10 +90,10 @@ func NewBlockchainReactor( state state.State, blockApplier blockApplier, store blockStore, - fastSync bool, + blockSync bool, metrics *cons.Metrics) *BlockchainReactor { reporter := behavior.NewMockReporter() - return newReactor(state, store, reporter, blockApplier, fastSync, metrics) + return newReactor(state, store, reporter, blockApplier, blockSync, metrics) } // SetSwitch implements Reactor interface. @@ -137,22 +137,22 @@ func (r *BlockchainReactor) SetLogger(logger log.Logger) { // Start implements cmn.Service interface func (r *BlockchainReactor) Start() error { r.reporter = behavior.NewSwitchReporter(r.BaseReactor.Switch) - if r.fastSync.IsSet() { + if r.blockSync.IsSet() { err := r.startSync(nil) if err != nil { - return fmt.Errorf("failed to start fast sync: %w", err) + return fmt.Errorf("failed to start block sync: %w", err) } } return nil } -// startSync begins a fast sync, signaled by r.events being non-nil. If state is non-nil, +// startSync begins a block sync, signaled by r.events being non-nil. If state is non-nil, // the scheduler and processor is updated with this state on startup. func (r *BlockchainReactor) startSync(state *state.State) error { r.mtx.Lock() defer r.mtx.Unlock() if r.events != nil { - return errors.New("fast sync already in progress") + return errors.New("block sync already in progress") } r.events = make(chan Event, chBufferSize) go r.scheduler.start() @@ -167,7 +167,7 @@ func (r *BlockchainReactor) startSync(state *state.State) error { return nil } -// endSync ends a fast sync +// endSync ends a block sync func (r *BlockchainReactor) endSync() { r.mtx.Lock() defer r.mtx.Unlock() @@ -179,8 +179,8 @@ func (r *BlockchainReactor) endSync() { r.processor.stop() } -// SwitchToFastSync is called by the state sync reactor when switching to fast sync. -func (r *BlockchainReactor) SwitchToFastSync(state state.State) error { +// SwitchToBlockSync is called by the state sync reactor when switching to block sync. +func (r *BlockchainReactor) SwitchToBlockSync(state state.State) error { r.stateSynced = true state = state.Copy() @@ -434,7 +434,7 @@ func (r *BlockchainReactor) demux(events <-chan Event) { } else { r.lastSyncRate = 0.9*r.lastSyncRate + 0.1*newSyncRate } - r.logger.Info("Fast Sync Rate", "height", r.syncHeight, + r.logger.Info("block sync Rate", "height", r.syncHeight, "max_peer_height", r.maxPeerHeight, "blocks/s", r.lastSyncRate) lastHundred = time.Now() } @@ -442,12 +442,12 @@ func (r *BlockchainReactor) demux(events <-chan Event) { case pcBlockVerificationFailure: r.scheduler.send(event) case pcFinished: - r.logger.Info("Fast sync complete, switching to consensus") + r.logger.Info("block sync complete, switching to consensus") if !r.io.trySwitchToConsensus(event.tmState, event.blocksSynced > 0 || r.stateSynced) { r.logger.Error("Failed to switch to consensus reactor") } r.endSync() - r.fastSync.UnSet() + r.blockSync.UnSet() return case noOpEvent: default: @@ -617,14 +617,14 @@ func (r *BlockchainReactor) GetMaxPeerBlockHeight() int64 { } func (r *BlockchainReactor) GetTotalSyncedTime() time.Duration { - if !r.fastSync.IsSet() || r.syncStartTime.IsZero() { + if !r.blockSync.IsSet() || r.syncStartTime.IsZero() { return time.Duration(0) } return time.Since(r.syncStartTime) } func (r *BlockchainReactor) GetRemainingSyncTime() time.Duration { - if !r.fastSync.IsSet() { + if !r.blockSync.IsSet() { return time.Duration(0) } diff --git a/internal/blockchain/v2/reactor_test.go b/internal/blocksync/v2/reactor_test.go similarity index 99% rename from internal/blockchain/v2/reactor_test.go rename to internal/blocksync/v2/reactor_test.go index f4ded22da..4120b3942 100644 --- a/internal/blockchain/v2/reactor_test.go +++ b/internal/blocksync/v2/reactor_test.go @@ -15,7 +15,7 @@ import ( abci "github.com/tendermint/tendermint/abci/types" cfg "github.com/tendermint/tendermint/config" - "github.com/tendermint/tendermint/internal/blockchain/v2/internal/behavior" + "github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior" cons "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/mempool/mock" "github.com/tendermint/tendermint/internal/p2p" @@ -23,7 +23,7 @@ import ( "github.com/tendermint/tendermint/internal/test/factory" "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/service" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/proxy" sm "github.com/tendermint/tendermint/state" sf "github.com/tendermint/tendermint/state/test/factory" diff --git a/internal/blockchain/v2/routine.go b/internal/blocksync/v2/routine.go similarity index 100% rename from internal/blockchain/v2/routine.go rename to internal/blocksync/v2/routine.go diff --git a/internal/blockchain/v2/routine_test.go b/internal/blocksync/v2/routine_test.go similarity index 100% rename from internal/blockchain/v2/routine_test.go rename to internal/blocksync/v2/routine_test.go diff --git a/internal/blockchain/v2/scheduler.go b/internal/blocksync/v2/scheduler.go similarity index 99% rename from internal/blockchain/v2/scheduler.go rename to internal/blocksync/v2/scheduler.go index f884a66ed..b731d96a4 100644 --- a/internal/blockchain/v2/scheduler.go +++ b/internal/blocksync/v2/scheduler.go @@ -163,7 +163,7 @@ type scheduler struct { height int64 // lastAdvance tracks the last time a block execution happened. - // syncTimeout is the maximum time the scheduler waits to advance in the fast sync process before finishing. + // syncTimeout is the maximum time the scheduler waits to advance in the block sync process before finishing. // This covers the cases where there are no peers or all peers have a lower height. lastAdvance time.Time syncTimeout time.Duration diff --git a/internal/blockchain/v2/scheduler_test.go b/internal/blocksync/v2/scheduler_test.go similarity index 100% rename from internal/blockchain/v2/scheduler_test.go rename to internal/blocksync/v2/scheduler_test.go diff --git a/internal/blockchain/v2/types.go b/internal/blocksync/v2/types.go similarity index 100% rename from internal/blockchain/v2/types.go rename to internal/blocksync/v2/types.go diff --git a/internal/consensus/metrics.go b/internal/consensus/metrics.go index 5b4c47502..bceac4942 100644 --- a/internal/consensus/metrics.go +++ b/internal/consensus/metrics.go @@ -54,8 +54,8 @@ type Metrics struct { TotalTxs metrics.Gauge // The latest block height. CommittedHeight metrics.Gauge - // 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 @@ -169,11 +169,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, @@ -214,7 +214,7 @@ func NopMetrics() *Metrics { BlockSizeBytes: discard.NewHistogram(), TotalTxs: discard.NewGauge(), CommittedHeight: discard.NewGauge(), - FastSyncing: discard.NewGauge(), + BlockSyncing: discard.NewGauge(), StateSyncing: discard.NewGauge(), BlockParts: discard.NewCounter(), } diff --git a/internal/consensus/mocks/cons_sync_reactor.go b/internal/consensus/mocks/cons_sync_reactor.go index fcaa5696d..f21094dbb 100644 --- a/internal/consensus/mocks/cons_sync_reactor.go +++ b/internal/consensus/mocks/cons_sync_reactor.go @@ -12,8 +12,8 @@ type ConsSyncReactor struct { mock.Mock } -// SetFastSyncingMetrics provides a mock function with given fields: _a0 -func (_m *ConsSyncReactor) SetFastSyncingMetrics(_a0 float64) { +// SetBlockSyncingMetrics provides a mock function with given fields: _a0 +func (_m *ConsSyncReactor) SetBlockSyncingMetrics(_a0 float64) { _m.Called(_a0) } diff --git a/internal/consensus/mocks/fast_sync_reactor.go b/internal/consensus/mocks/fast_sync_reactor.go index f6a7fabbc..b7f521ff2 100644 --- a/internal/consensus/mocks/fast_sync_reactor.go +++ b/internal/consensus/mocks/fast_sync_reactor.go @@ -9,13 +9,13 @@ import ( time "time" ) -// FastSyncReactor is an autogenerated mock type for the FastSyncReactor type -type FastSyncReactor struct { +// BlockSyncReactor is an autogenerated mock type for the BlockSyncReactor type +type BlockSyncReactor struct { mock.Mock } // GetMaxPeerBlockHeight provides a mock function with given fields: -func (_m *FastSyncReactor) GetMaxPeerBlockHeight() int64 { +func (_m *BlockSyncReactor) GetMaxPeerBlockHeight() int64 { ret := _m.Called() var r0 int64 @@ -29,7 +29,7 @@ func (_m *FastSyncReactor) GetMaxPeerBlockHeight() int64 { } // GetRemainingSyncTime provides a mock function with given fields: -func (_m *FastSyncReactor) GetRemainingSyncTime() time.Duration { +func (_m *BlockSyncReactor) GetRemainingSyncTime() time.Duration { ret := _m.Called() var r0 time.Duration @@ -43,7 +43,7 @@ func (_m *FastSyncReactor) GetRemainingSyncTime() time.Duration { } // GetTotalSyncedTime provides a mock function with given fields: -func (_m *FastSyncReactor) GetTotalSyncedTime() time.Duration { +func (_m *BlockSyncReactor) GetTotalSyncedTime() time.Duration { ret := _m.Called() var r0 time.Duration @@ -56,8 +56,8 @@ func (_m *FastSyncReactor) GetTotalSyncedTime() time.Duration { return r0 } -// SwitchToFastSync provides a mock function with given fields: _a0 -func (_m *FastSyncReactor) SwitchToFastSync(_a0 state.State) error { +// SwitchToBlockSync provides a mock function with given fields: _a0 +func (_m *BlockSyncReactor) SwitchToBlockSync(_a0 state.State) error { ret := _m.Called(_a0) var r0 error diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go index e01a6f329..4a19787c1 100644 --- a/internal/consensus/reactor.go +++ b/internal/consensus/reactor.go @@ -96,18 +96,18 @@ const ( type ReactorOption func(*Reactor) -// Temporary interface for switching to fast sync, we should get rid of v0. +// NOTE: Temporary interface for switching to block sync, we should get rid of v0. // See: https://github.com/tendermint/tendermint/issues/4595 -type FastSyncReactor interface { - SwitchToFastSync(sm.State) error +type BlockSyncReactor interface { + SwitchToBlockSync(sm.State) error GetMaxPeerBlockHeight() int64 - // GetTotalSyncedTime returns the time duration since the fastsync starting. + // GetTotalSyncedTime returns the time duration since the blocksync starting. GetTotalSyncedTime() time.Duration // GetRemainingSyncTime returns the estimating time the node will be fully synced, - // if will return 0 if the fastsync does not perform or the number of block synced is + // if will return 0 if the blocksync does not perform or the number of block synced is // too small (less than 100). GetRemainingSyncTime() time.Duration } @@ -117,7 +117,7 @@ type FastSyncReactor interface { type ConsSyncReactor interface { SwitchToConsensus(sm.State, bool) SetStateSyncingMetrics(float64) - SetFastSyncingMetrics(float64) + SetBlockSyncingMetrics(float64) } // Reactor defines a reactor for the consensus service. @@ -265,7 +265,7 @@ func (r *Reactor) SetEventBus(b *types.EventBus) { r.state.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 (r *Reactor) WaitSync() bool { r.mtx.RLock() defer r.mtx.RUnlock() @@ -278,8 +278,8 @@ func ReactorMetrics(metrics *Metrics) ReactorOption { return func(r *Reactor) { r.Metrics = metrics } } -// 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 (r *Reactor) SwitchToConsensus(state sm.State, skipWAL bool) { r.Logger.Info("switching to consensus") @@ -296,7 +296,7 @@ func (r *Reactor) SwitchToConsensus(state sm.State, skipWAL bool) { r.waitSync = false r.mtx.Unlock() - r.Metrics.FastSyncing.Set(0) + r.Metrics.BlockSyncing.Set(0) r.Metrics.StateSyncing.Set(0) if skipWAL { @@ -313,9 +313,9 @@ conR: %+v`, err, r.state, r)) } - d := types.EventDataFastSyncStatus{Complete: true, Height: state.LastBlockHeight} - if err := r.eventBus.PublishEventFastSyncStatus(d); err != nil { - r.Logger.Error("failed to emit the fastsync complete event", "err", err) + d := types.EventDataBlockSyncStatus{Complete: true, Height: state.LastBlockHeight} + if err := r.eventBus.PublishEventBlockSyncStatus(d); err != nil { + r.Logger.Error("failed to emit the blocksync complete event", "err", err) } } @@ -969,7 +969,7 @@ func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) { go r.gossipVotesRoutine(ps) go r.queryMaj23Routine(ps) - // Send our state to the peer. If we're fast-syncing, broadcast a + // Send our state to the peer. If we're block-syncing, broadcast a // RoundStepMessage later upon SwitchToConsensus(). if !r.waitSync { go r.sendNewRoundStepMessage(ps.peerID) @@ -1219,7 +1219,7 @@ func (r *Reactor) handleVoteSetBitsMessage(envelope p2p.Envelope, msgI Message) // It will handle errors and any possible panics gracefully. A caller can handle // any error returned by sending a PeerError on the respective channel. // -// NOTE: We process these messages even when we're fast_syncing. Messages affect +// 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 p2p channel. @@ -1442,6 +1442,6 @@ func (r *Reactor) SetStateSyncingMetrics(v float64) { r.Metrics.StateSyncing.Set(v) } -func (r *Reactor) SetFastSyncingMetrics(v float64) { - r.Metrics.FastSyncing.Set(v) +func (r *Reactor) SetBlockSyncingMetrics(v float64) { + r.Metrics.BlockSyncing.Set(v) } diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go index 900abc0ff..8c70ca1d5 100644 --- a/internal/consensus/reactor_test.go +++ b/internal/consensus/reactor_test.go @@ -43,7 +43,7 @@ type reactorTestSuite struct { states map[types.NodeID]*State reactors map[types.NodeID]*Reactor subs map[types.NodeID]types.Subscription - fastsyncSubs map[types.NodeID]types.Subscription + blocksyncSubs map[types.NodeID]types.Subscription stateChannels map[types.NodeID]*p2p.Channel dataChannels map[types.NodeID]*p2p.Channel voteChannels map[types.NodeID]*p2p.Channel @@ -60,11 +60,11 @@ func setup(t *testing.T, numNodes int, states []*State, size int) *reactorTestSu t.Helper() rts := &reactorTestSuite{ - network: p2ptest.MakeNetwork(t, p2ptest.NetworkOptions{NumNodes: numNodes}), - states: make(map[types.NodeID]*State), - reactors: make(map[types.NodeID]*Reactor, numNodes), - subs: make(map[types.NodeID]types.Subscription, numNodes), - fastsyncSubs: make(map[types.NodeID]types.Subscription, numNodes), + network: p2ptest.MakeNetwork(t, p2ptest.NetworkOptions{NumNodes: numNodes}), + states: make(map[types.NodeID]*State), + reactors: make(map[types.NodeID]*Reactor, numNodes), + subs: make(map[types.NodeID]types.Subscription, numNodes), + blocksyncSubs: make(map[types.NodeID]types.Subscription, numNodes), } rts.stateChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(StateChannel), new(tmcons.Message), size) @@ -94,13 +94,13 @@ func setup(t *testing.T, numNodes int, states []*State, size int) *reactorTestSu blocksSub, err := state.eventBus.Subscribe(context.Background(), testSubscriber, types.EventQueryNewBlock, size) require.NoError(t, err) - fsSub, err := state.eventBus.Subscribe(context.Background(), testSubscriber, types.EventQueryFastSyncStatus, size) + fsSub, err := state.eventBus.Subscribe(context.Background(), testSubscriber, types.EventQueryBlockSyncStatus, size) require.NoError(t, err) rts.states[nodeID] = state rts.subs[nodeID] = blocksSub rts.reactors[nodeID] = reactor - rts.fastsyncSubs[nodeID] = fsSub + rts.blocksyncSubs[nodeID] = fsSub // simulate handle initChain in handshake if state.state.LastBlockHeight == 0 { @@ -263,9 +263,9 @@ func waitForBlockWithUpdatedValsAndValidateIt( wg.Wait() } -func ensureFastSyncStatus(t *testing.T, msg tmpubsub.Message, complete bool, height int64) { +func ensureBlockSyncStatus(t *testing.T, msg tmpubsub.Message, complete bool, height int64) { t.Helper() - status, ok := msg.Data().(types.EventDataFastSyncStatus) + status, ok := msg.Data().(types.EventDataBlockSyncStatus) require.True(t, ok) require.Equal(t, complete, status.Complete) @@ -301,14 +301,14 @@ func TestReactorBasic(t *testing.T) { wg.Wait() - for _, sub := range rts.fastsyncSubs { + for _, sub := range rts.blocksyncSubs { wg.Add(1) // wait till everyone makes the consensus switch go func(s types.Subscription) { defer wg.Done() msg := <-s.Out() - ensureFastSyncStatus(t, msg, true, 0) + ensureBlockSyncStatus(t, msg, true, 0) }(sub) } diff --git a/node/node.go b/node/node.go index 994132b29..ced8af729 100644 --- a/node/node.go +++ b/node/node.go @@ -66,7 +66,7 @@ type nodeImpl struct { eventBus *types.EventBus // pub/sub for services stateStore sm.Store blockStore *store.BlockStore // store the blockchain to disk - bcReactor service.Service // for fast-syncing + bcReactor service.Service // for block-syncing mempoolReactor service.Service // for gossipping transactions mempool mempool.Mempool stateSync bool // whether the node should state sync on startup @@ -225,9 +225,9 @@ func makeNode(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.FastSyncMode && !onlyValidatorIsUs(state, pubKey) logNodeStartupInfo(state, pubKey, logger, consensusLogger, config.Mode) @@ -281,15 +281,15 @@ func makeNode(config *cfg.Config, csReactorShim, csReactor, csState := createConsensusReactor( config, state, blockExec, blockStore, mp, evPool, - privValidator, csMetrics, stateSync || fastSync, eventBus, + privValidator, csMetrics, stateSync || blockSync, eventBus, peerManager, router, consensusLogger, ) - // Create the blockchain reactor. Note, we do not start fast sync if we're + // Create the blockchain reactor. Note, we do not start block sync if we're // doing a state sync first. bcReactorShim, bcReactor, err := createBlockchainReactor( logger, config, state, blockExec, blockStore, csReactor, - peerManager, router, fastSync && !stateSync, csMetrics, + peerManager, router, blockSync && !stateSync, csMetrics, ) if err != nil { return nil, fmt.Errorf("could not create blockchain reactor: %w", err) @@ -303,16 +303,16 @@ func makeNode(config *cfg.Config, bcReactorForSwitch = bcReactor.(p2p.Reactor) } - // 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) } // 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 var ( @@ -610,7 +610,7 @@ func (n *nodeImpl) OnStart() error { } if n.config.Mode != cfg.ModeSeed { - if n.config.FastSync.Version == cfg.BlockchainV0 { + if n.config.BlockSync.Version == cfg.BlockSyncV0 { // Start the real blockchain reactor separately since the switch uses the shim. if err := n.bcReactor.Start(); err != nil { return err @@ -653,7 +653,7 @@ func (n *nodeImpl) OnStart() error { // Run state sync if n.stateSync { - bcR, ok := n.bcReactor.(cs.FastSyncReactor) + bcR, ok := n.bcReactor.(cs.BlockSyncReactor) if !ok { return fmt.Errorf("this blockchain reactor does not support switching from state sync") } @@ -695,7 +695,7 @@ func (n *nodeImpl) OnStop() { if n.config.Mode != cfg.ModeSeed { // now stop the reactors - if n.config.FastSync.Version == cfg.BlockchainV0 { + if n.config.BlockSync.Version == cfg.BlockSyncV0 { // Stop the real blockchain reactor separately since the switch uses the shim. if err := n.bcReactor.Stop(); err != nil { n.Logger.Error("failed to stop the blockchain reactor", "err", err) @@ -788,8 +788,8 @@ func (n *nodeImpl) ConfigureRPC() (*rpccore.Environment, error) { Logger: n.Logger.With("module", "rpc"), - Config: *n.config.RPC, - FastSyncReactor: n.bcReactor.(cs.FastSyncReactor), + Config: *n.config.RPC, + BlockSyncReactor: n.bcReactor.(cs.BlockSyncReactor), } if n.config.Mode == cfg.ModeValidator { pubKey, err := n.privValidator.GetPubKey(context.TODO()) @@ -1033,14 +1033,14 @@ func (n *nodeImpl) NodeInfo() types.NodeInfo { return n.nodeInfo } -// startStateSync starts an asynchronous state sync process, then switches to fast sync mode. +// startStateSync starts an asynchronous state sync process, then switches to block sync mode. func startStateSync( ssR statesync.SyncReactor, - bcR cs.FastSyncReactor, + bcR cs.BlockSyncReactor, conR cs.ConsSyncReactor, sp statesync.StateProvider, config *cfg.StateSyncConfig, - fastSync bool, + blockSync bool, stateInitHeight int64, eb *types.EventBus, ) error { @@ -1074,17 +1074,17 @@ func startStateSync( stateSyncLogger.Error("failed to emit the statesync start event", "err", err) } - if fastSync { + if blockSync { // FIXME Very ugly to have these metrics bleed through here. - conR.SetFastSyncingMetrics(1) - if err := bcR.SwitchToFastSync(state); err != nil { - stateSyncLogger.Error("failed to switch to fast sync", "err", err) + conR.SetBlockSyncingMetrics(1) + if err := bcR.SwitchToBlockSync(state); err != nil { + stateSyncLogger.Error("failed to switch to block sync", "err", err) return } - d := types.EventDataFastSyncStatus{Complete: false, Height: state.LastBlockHeight} - if err := eb.PublishEventFastSyncStatus(d); err != nil { - stateSyncLogger.Error("failed to emit the fastsync starting event", "err", err) + d := types.EventDataBlockSyncStatus{Complete: false, Height: state.LastBlockHeight} + if err := eb.PublishEventBlockSyncStatus(d); err != nil { + stateSyncLogger.Error("failed to emit the block sync starting event", "err", err) } } else { diff --git a/node/node_test.go b/node/node_test.go index eca622bd3..16edb4210 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -659,7 +659,7 @@ func loadStatefromGenesis(t *testing.T) sm.State { func TestNodeStartStateSync(t *testing.T) { mockSSR := &statesync.MockSyncReactor{} - mockFSR := &consmocks.FastSyncReactor{} + mockFSR := &consmocks.BlockSyncReactor{} mockCSR := &consmocks.ConsSyncReactor{} mockSP := &ssmocks.StateProvider{} state := loadStatefromGenesis(t) diff --git a/node/setup.go b/node/setup.go index cd1875fb6..af48fb382 100644 --- a/node/setup.go +++ b/node/setup.go @@ -16,8 +16,8 @@ import ( abci "github.com/tendermint/tendermint/abci/types" cfg "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto" - bcv0 "github.com/tendermint/tendermint/internal/blockchain/v0" - bcv2 "github.com/tendermint/tendermint/internal/blockchain/v2" + bcv0 "github.com/tendermint/tendermint/internal/blocksync/v0" + bcv2 "github.com/tendermint/tendermint/internal/blocksync/v2" cs "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/evidence" "github.com/tendermint/tendermint/internal/mempool" @@ -337,14 +337,14 @@ func createBlockchainReactor( csReactor *cs.Reactor, peerManager *p2p.PeerManager, router *p2p.Router, - fastSync bool, + blockSync bool, metrics *cs.Metrics, ) (*p2p.ReactorShim, service.Service, error) { logger = logger.With("module", "blockchain") - switch config.FastSync.Version { - case cfg.BlockchainV0: + switch config.BlockSync.Version { + case cfg.BlockSyncV0: reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", bcv0.ChannelShims) var ( @@ -362,7 +362,7 @@ func createBlockchainReactor( reactor, err := bcv0.NewReactor( logger, state.Copy(), blockExec, blockStore, csReactor, - channels[bcv0.BlockchainChannel], peerUpdates, fastSync, + channels[bcv0.BlockchainChannel], peerUpdates, blockSync, metrics, ) if err != nil { @@ -371,11 +371,11 @@ func createBlockchainReactor( return reactorShim, reactor, nil - case cfg.BlockchainV2: - return nil, nil, errors.New("fastsync version v2 is no longer supported. Please use v0") + case cfg.BlockSyncV2: + return nil, nil, errors.New("block sync version v2 is no longer supported. Please use v0") default: - return nil, nil, fmt.Errorf("unknown fastsync version %s", config.FastSync.Version) + return nil, nil, fmt.Errorf("unknown block sync version %s", config.BlockSync.Version) } } @@ -725,15 +725,15 @@ func makeNodeInfo( } var bcChannel byte - switch config.FastSync.Version { - case cfg.BlockchainV0: + switch config.BlockSync.Version { + case cfg.BlockSyncV0: bcChannel = byte(bcv0.BlockchainChannel) - case cfg.BlockchainV2: + case cfg.BlockSyncV2: bcChannel = bcv2.BlockchainChannel default: - return types.NodeInfo{}, fmt.Errorf("unknown fastsync version %s", config.FastSync.Version) + return types.NodeInfo{}, fmt.Errorf("unknown blocksync version %s", config.BlockSync.Version) } nodeInfo := types.NodeInfo{ diff --git a/proto/tendermint/blockchain/message.go b/proto/tendermint/blocksync/message.go similarity index 99% rename from proto/tendermint/blockchain/message.go rename to proto/tendermint/blocksync/message.go index 6143a64e7..d448ccc4b 100644 --- a/proto/tendermint/blockchain/message.go +++ b/proto/tendermint/blocksync/message.go @@ -1,4 +1,4 @@ -package blockchain +package blocksync import ( "errors" diff --git a/proto/tendermint/blockchain/message_test.go b/proto/tendermint/blocksync/message_test.go similarity index 99% rename from proto/tendermint/blockchain/message_test.go rename to proto/tendermint/blocksync/message_test.go index 37a0df217..dd1aebbd0 100644 --- a/proto/tendermint/blockchain/message_test.go +++ b/proto/tendermint/blocksync/message_test.go @@ -1,4 +1,4 @@ -package blockchain_test +package blocksync_test import ( "encoding/hex" @@ -8,7 +8,7 @@ import ( proto "github.com/gogo/protobuf/proto" "github.com/stretchr/testify/require" - bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain" + bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/types" ) 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/rpc/core/env.go b/rpc/core/env.go index c18e84b51..eb7232c01 100644 --- a/rpc/core/env.go +++ b/rpc/core/env.go @@ -81,7 +81,7 @@ type Environment struct { ConsensusReactor *consensus.Reactor EventBus *types.EventBus // thread safe Mempool mempl.Mempool - FastSyncReactor consensus.FastSyncReactor + BlockSyncReactor consensus.BlockSyncReactor Logger log.Logger diff --git a/rpc/core/status.go b/rpc/core/status.go index 9febef195..815ab37f5 100644 --- a/rpc/core/status.go +++ b/rpc/core/status.go @@ -69,10 +69,10 @@ func (env *Environment) Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, err EarliestAppHash: earliestAppHash, EarliestBlockHeight: earliestBlockHeight, EarliestBlockTime: time.Unix(0, earliestBlockTimeNano), - MaxPeerBlockHeight: env.FastSyncReactor.GetMaxPeerBlockHeight(), + MaxPeerBlockHeight: env.BlockSyncReactor.GetMaxPeerBlockHeight(), CatchingUp: env.ConsensusReactor.WaitSync(), - TotalSyncedTime: env.FastSyncReactor.GetTotalSyncedTime(), - RemainingTime: env.FastSyncReactor.GetRemainingSyncTime(), + TotalSyncedTime: env.BlockSyncReactor.GetTotalSyncedTime(), + RemainingTime: env.BlockSyncReactor.GetRemainingSyncTime(), }, ValidatorInfo: validatorInfo, } diff --git a/test/e2e/README.md b/test/e2e/README.md index 6811b6561..d737120c1 100644 --- a/test/e2e/README.md +++ b/test/e2e/README.md @@ -23,7 +23,7 @@ The above should hold for any arbitrary, valid network configuration, and that c A testnet configuration is specified as a TOML testnet manifest (see below). The testnet runner uses the manifest to configure a set of Docker containers and start them in some order. The manifests can be written manually (to test specific configurations) or generated randomly by the testnet generator (to test a wide range of configuration permutations). -When running a testnet, the runner will first start the Docker nodes in some sequence, submit random transactions, and wait for the nodes to come online and the first blocks to be produced. This may involve e.g. waiting for nodes to fast sync and/or state sync. If specified, it will then run any misbehaviors (e.g. double-signing) and perturbations (e.g. killing or disconnecting nodes). It then waits for the testnet to stabilize, with all nodes online and having reached the latest height. +When running a testnet, the runner will first start the Docker nodes in some sequence, submit random transactions, and wait for the nodes to come online and the first blocks to be produced. This may involve e.g. waiting for nodes to block sync and/or state sync. If specified, it will then run any misbehaviors (e.g. double-signing) and perturbations (e.g. killing or disconnecting nodes). It then waits for the testnet to stabilize, with all nodes online and having reached the latest height. Once the testnet stabilizes, a set of Go end-to-end tests are run against the live testnet to verify network invariants (for example that blocks are identical across nodes). These use the RPC client to interact with the network, and should consider the entire network as a black box (i.e. it should not test any network or node internals, only externally visible behavior via RPC). The tests may use the `testNode()` helper to run parallel tests against each individual testnet node, and/or inspect the full blockchain history via `fetchBlockChain()`. diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go index 1e134cf71..f699b1162 100644 --- a/test/e2e/generator/generate.go +++ b/test/e2e/generator/generate.go @@ -30,7 +30,7 @@ var ( nodeABCIProtocols = uniformChoice{"unix", "tcp", "builtin", "grpc"} nodePrivvalProtocols = uniformChoice{"file", "unix", "tcp", "grpc"} // FIXME: v2 disabled due to flake - nodeFastSyncs = uniformChoice{"v0"} // "v2" + nodeBlockSyncs = uniformChoice{"v0"} // "v2" nodeMempools = uniformChoice{"v0", "v1"} nodeStateSyncs = uniformChoice{false, true} nodePersistIntervals = uniformChoice{0, 1, 5} @@ -273,7 +273,7 @@ func generateNode( Database: nodeDatabases.Choose(r).(string), ABCIProtocol: nodeABCIProtocols.Choose(r).(string), PrivvalProtocol: nodePrivvalProtocols.Choose(r).(string), - FastSync: nodeFastSyncs.Choose(r).(string), + BlockSync: nodeBlockSyncs.Choose(r).(string), Mempool: nodeMempools.Choose(r).(string), StateSync: nodeStateSyncs.Choose(r).(bool) && startAt > 0, PersistInterval: ptrUint64(uint64(nodePersistIntervals.Choose(r).(int))), @@ -311,7 +311,7 @@ func generateNode( } if node.StateSync { - node.FastSync = "v0" + node.BlockSync = "v0" } return &node diff --git a/test/e2e/networks/ci.toml b/test/e2e/networks/ci.toml index afce3a2db..00c73ccbd 100644 --- a/test/e2e/networks/ci.toml +++ b/test/e2e/networks/ci.toml @@ -30,11 +30,6 @@ validator05 = 50 [node.seed01] mode = "seed" perturb = ["restart"] -seeds = ["seed02"] - -[node.seed02] -mode = "seed" -seeds = ["seed01"] [node.validator01] perturb = ["disconnect"] @@ -47,7 +42,7 @@ database = "boltdb" persist_interval = 0 perturb = ["restart"] privval_protocol = "tcp" -seeds = ["seed02"] +seeds = ["seed01"] [node.validator03] database = "badgerdb" @@ -66,29 +61,21 @@ perturb = ["pause"] [node.validator05] database = "cleveldb" -fast_sync = "v0" -seeds = ["seed02"] +block_sync = "v0" +seeds = ["seed01"] start_at = 1005 # Becomes part of the validator set at 1010 abci_protocol = "grpc" -perturb = ["kill", "pause", "disconnect", "restart"] +perturb = ["pause", "disconnect", "restart"] privval_protocol = "tcp" [node.full01] mode = "full" start_at = 1010 # FIXME: should be v2, disabled due to flake -fast_sync = "v0" +block_sync = "v0" persistent_peers = ["validator01", "validator02", "validator03", "validator04", "validator05"] perturb = ["restart"] retain_blocks = 7 - -[node.full02] -mode = "full" -start_at = 1015 -# FIXME: should be v2, disabled due to flake -fast_sync = "v0" -perturb = ["restart"] -seeds = ["seed01"] state_sync = true [node.light01] diff --git a/test/e2e/pkg/manifest.go b/test/e2e/pkg/manifest.go index 89b38e02a..5711be37d 100644 --- a/test/e2e/pkg/manifest.go +++ b/test/e2e/pkg/manifest.go @@ -106,9 +106,9 @@ type ManifestNode struct { // runner will wait for the network to reach at least this block height. StartAt int64 `toml:"start_at"` - // FastSync specifies the fast sync mode: "" (disable), "v0" or "v2". + // BlockSync specifies the block sync mode: "" (disable), "v0" or "v2". // Defaults to disabled. - FastSync string `toml:"fast_sync"` + BlockSync string `toml:"block_sync"` // Mempool specifies which version of mempool to use. Either "v0" or "v1" Mempool string `toml:"mempool_version"` diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go index d54df4406..cfeb54bde 100644 --- a/test/e2e/pkg/testnet.go +++ b/test/e2e/pkg/testnet.go @@ -79,7 +79,7 @@ type Node struct { IP net.IP ProxyPort uint32 StartAt int64 - FastSync string + BlockSync string Mempool string StateSync bool Database string @@ -168,7 +168,7 @@ func LoadTestnet(file string) (*Testnet, error) { ABCIProtocol: ProtocolBuiltin, PrivvalProtocol: ProtocolFile, StartAt: nodeManifest.StartAt, - FastSync: nodeManifest.FastSync, + BlockSync: nodeManifest.BlockSync, Mempool: nodeManifest.Mempool, StateSync: nodeManifest.StateSync, PersistInterval: 1, @@ -328,10 +328,10 @@ func (n Node) Validate(testnet Testnet) error { } } } - switch n.FastSync { + switch n.BlockSync { case "", "v0", "v2": default: - return fmt.Errorf("invalid fast sync setting %q", n.FastSync) + return fmt.Errorf("invalid block sync setting %q", n.BlockSync) } switch n.Mempool { case "", "v0", "v1": diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go index c80d05b22..c968ef306 100644 --- a/test/e2e/runner/setup.go +++ b/test/e2e/runner/setup.go @@ -296,10 +296,10 @@ func MakeConfig(node *e2e.Node) (*config.Config, error) { cfg.Mempool.Version = node.Mempool } - if node.FastSync == "" { + if node.BlockSync == "" { cfg.FastSyncMode = false } else { - cfg.FastSync.Version = node.FastSync + cfg.BlockSync.Version = node.BlockSync } if node.StateSync { diff --git a/types/event_bus.go b/types/event_bus.go index 5290181ee..dfe3a0664 100644 --- a/types/event_bus.go +++ b/types/event_bus.go @@ -153,8 +153,8 @@ func (b *EventBus) PublishEventValidBlock(data EventDataRoundState) error { return b.Publish(EventValidBlockValue, data) } -func (b *EventBus) PublishEventFastSyncStatus(data EventDataFastSyncStatus) error { - return b.Publish(EventFastSyncStatusValue, data) +func (b *EventBus) PublishEventBlockSyncStatus(data EventDataBlockSyncStatus) error { + return b.Publish(EventBlockSyncStatusValue, data) } func (b *EventBus) PublishEventStateSyncStatus(data EventDataStateSyncStatus) error { @@ -317,7 +317,7 @@ func (NopEventBus) PublishEventValidatorSetUpdates(data EventDataValidatorSetUpd return nil } -func (NopEventBus) PublishEventFastSyncStatus(data EventDataFastSyncStatus) error { +func (NopEventBus) PublishEventBlockSyncStatus(data EventDataBlockSyncStatus) error { return nil } diff --git a/types/event_bus_test.go b/types/event_bus_test.go index 987a10eab..9ca075391 100644 --- a/types/event_bus_test.go +++ b/types/event_bus_test.go @@ -370,7 +370,7 @@ func TestEventBusPublish(t *testing.T) { require.NoError(t, err) err = eventBus.PublishEventValidatorSetUpdates(EventDataValidatorSetUpdates{}) require.NoError(t, err) - err = eventBus.PublishEventFastSyncStatus(EventDataFastSyncStatus{}) + err = eventBus.PublishEventBlockSyncStatus(EventDataBlockSyncStatus{}) require.NoError(t, err) err = eventBus.PublishEventStateSyncStatus(EventDataStateSyncStatus{}) require.NoError(t, err) @@ -480,7 +480,7 @@ var events = []string{ EventRelockValue, EventTimeoutWaitValue, EventVoteValue, - EventFastSyncStatusValue, + EventBlockSyncStatusValue, EventStateSyncStatusValue, } @@ -502,7 +502,9 @@ var queries = []tmpubsub.Query{ EventQueryRelock, EventQueryTimeoutWait, EventQueryVote, - EventQueryFastSyncStatus} + EventQueryBlockSyncStatus, + EventQueryStateSyncStatus, +} func randQuery() tmpubsub.Query { return queries[mrand.Intn(len(queries))] diff --git a/types/events.go b/types/events.go index 2e234d3b7..46f150abd 100644 --- a/types/events.go +++ b/types/events.go @@ -27,9 +27,9 @@ const ( // These are used for testing the consensus state machine. // They can also be used to build real-time consensus visualizers. EventCompleteProposalValue = "CompleteProposal" - // The FastSyncStatus event will be emitted when the node switching - // state sync mechanism between the consensus reactor and the fastsync reactor. - EventFastSyncStatusValue = "FastSyncStatus" + // The BlockSyncStatus event will be emitted when the node switching + // state sync mechanism between the consensus reactor and the blocksync reactor. + EventBlockSyncStatusValue = "BlockSyncStatus" EventLockValue = "Lock" EventNewRoundValue = "NewRound" EventNewRoundStepValue = "NewRoundStep" @@ -104,7 +104,7 @@ func init() { tmjson.RegisterType(EventDataVote{}, "tendermint/event/Vote") tmjson.RegisterType(EventDataValidatorSetUpdates{}, "tendermint/event/ValidatorSetUpdates") tmjson.RegisterType(EventDataString(""), "tendermint/event/ProposalString") - tmjson.RegisterType(EventDataFastSyncStatus{}, "tendermint/event/FastSyncStatus") + tmjson.RegisterType(EventDataBlockSyncStatus{}, "tendermint/event/FastSyncStatus") tmjson.RegisterType(EventDataStateSyncStatus{}, "tendermint/event/StateSyncStatus") } @@ -176,9 +176,9 @@ type EventDataValidatorSetUpdates struct { ValidatorUpdates []*Validator `json:"validator_updates"` } -// EventDataFastSyncStatus shows the fastsync status and the +// EventDataBlockSyncStatus shows the fastsync status and the // height when the node state sync mechanism changes. -type EventDataFastSyncStatus struct { +type EventDataBlockSyncStatus struct { Complete bool `json:"complete"` Height int64 `json:"height"` } @@ -227,7 +227,7 @@ var ( EventQueryValidatorSetUpdates = QueryForEvent(EventValidatorSetUpdatesValue) EventQueryValidBlock = QueryForEvent(EventValidBlockValue) EventQueryVote = QueryForEvent(EventVoteValue) - EventQueryFastSyncStatus = QueryForEvent(EventFastSyncStatusValue) + EventQueryBlockSyncStatus = QueryForEvent(EventBlockSyncStatusValue) EventQueryStateSyncStatus = QueryForEvent(EventStateSyncStatusValue) ) From 9e41414a53c6ddde0ecc2b37fa9c5231642a9d44 Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Wed, 28 Jul 2021 12:12:11 -0400 Subject: [PATCH 13/35] light: replace homegrown mock with mockery (#6735) This pull request removes the homegrown mocks in `light/provider/mock` in favor of mockery mocks. Adds a simple benchmark only mock to avoid the overhead of `reflection` that `mockery` incurs. part of #5274 --- light/client_benchmark_test.go | 55 +++- light/client_test.go | 484 ++++++++++++++++++------------- light/detector_test.go | 386 ++++++++++++++---------- light/helpers_test.go | 37 ++- light/provider/mock/deadmock.go | 30 -- light/provider/mock/mock.go | 125 -------- light/provider/mocks/provider.go | 53 ++++ 7 files changed, 630 insertions(+), 540 deletions(-) delete mode 100644 light/provider/mock/deadmock.go delete mode 100644 light/provider/mock/mock.go create mode 100644 light/provider/mocks/provider.go diff --git a/light/client_benchmark_test.go b/light/client_benchmark_test.go index 72930928d..04ea6d1fc 100644 --- a/light/client_benchmark_test.go +++ b/light/client_benchmark_test.go @@ -10,8 +10,8 @@ import ( "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/light" "github.com/tendermint/tendermint/light/provider" - mockp "github.com/tendermint/tendermint/light/provider/mock" dbs "github.com/tendermint/tendermint/light/store/db" + "github.com/tendermint/tendermint/types" ) // NOTE: block is produced every minute. Make sure the verification time @@ -21,12 +21,50 @@ import ( // or -benchtime 100x. // // Remember that none of these benchmarks account for network latency. -var ( - benchmarkFullNode = mockp.New(genMockNode(chainID, 1000, 100, 1, bTime)) - genesisBlock, _ = benchmarkFullNode.LightBlock(context.Background(), 1) -) +var () + +type providerBenchmarkImpl struct { + currentHeight int64 + blocks map[int64]*types.LightBlock +} + +func newProviderBenchmarkImpl(headers map[int64]*types.SignedHeader, + vals map[int64]*types.ValidatorSet) provider.Provider { + impl := providerBenchmarkImpl{ + blocks: make(map[int64]*types.LightBlock, len(headers)), + } + for height, header := range headers { + if height > impl.currentHeight { + impl.currentHeight = height + } + impl.blocks[height] = &types.LightBlock{ + SignedHeader: header, + ValidatorSet: vals[height], + } + } + return &impl +} + +func (impl *providerBenchmarkImpl) LightBlock(ctx context.Context, height int64) (*types.LightBlock, error) { + if height == 0 { + return impl.blocks[impl.currentHeight], nil + } + lb, ok := impl.blocks[height] + if !ok { + return nil, provider.ErrLightBlockNotFound + } + return lb, nil +} + +func (impl *providerBenchmarkImpl) ReportEvidence(_ context.Context, _ types.Evidence) error { + panic("not implemented") +} func BenchmarkSequence(b *testing.B) { + headers, vals, _ := genLightBlocksWithKeys(chainID, 1000, 100, 1, bTime) + benchmarkFullNode := newProviderBenchmarkImpl(headers, vals) + genesisBlock, _ := benchmarkFullNode.LightBlock(context.Background(), 1) + c, err := light.NewClient( context.Background(), chainID, @@ -55,6 +93,10 @@ func BenchmarkSequence(b *testing.B) { } func BenchmarkBisection(b *testing.B) { + headers, vals, _ := genLightBlocksWithKeys(chainID, 1000, 100, 1, bTime) + benchmarkFullNode := newProviderBenchmarkImpl(headers, vals) + genesisBlock, _ := benchmarkFullNode.LightBlock(context.Background(), 1) + c, err := light.NewClient( context.Background(), chainID, @@ -82,7 +124,10 @@ func BenchmarkBisection(b *testing.B) { } func BenchmarkBackwards(b *testing.B) { + headers, vals, _ := genLightBlocksWithKeys(chainID, 1000, 100, 1, bTime) + benchmarkFullNode := newProviderBenchmarkImpl(headers, vals) trustedBlock, _ := benchmarkFullNode.LightBlock(context.Background(), 0) + c, err := light.NewClient( context.Background(), chainID, diff --git a/light/client_test.go b/light/client_test.go index 67e0525b8..e8a478a53 100644 --- a/light/client_test.go +++ b/light/client_test.go @@ -3,11 +3,13 @@ package light_test import ( "context" "errors" + "fmt" "sync" "testing" "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" dbm "github.com/tendermint/tm-db" @@ -16,7 +18,7 @@ import ( "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/light" "github.com/tendermint/tendermint/light/provider" - mockp "github.com/tendermint/tendermint/light/provider/mock" + provider_mocks "github.com/tendermint/tendermint/light/provider/mocks" dbs "github.com/tendermint/tendermint/light/store/db" "github.com/tendermint/tendermint/types" ) @@ -57,14 +59,9 @@ var ( // last header (3/3 signed) 3: h3, } - l1 = &types.LightBlock{SignedHeader: h1, ValidatorSet: vals} - fullNode = mockp.New( - chainID, - headerSet, - valSet, - ) - deadNode = mockp.NewDeadMock(chainID) - largeFullNode = mockp.New(genMockNode(chainID, 10, 3, 0, bTime)) + l1 = &types.LightBlock{SignedHeader: h1, ValidatorSet: vals} + l2 = &types.LightBlock{SignedHeader: h2, ValidatorSet: vals} + l3 = &types.LightBlock{SignedHeader: h3, ValidatorSet: vals} ) func TestValidateTrustOptions(t *testing.T) { @@ -113,11 +110,6 @@ func TestValidateTrustOptions(t *testing.T) { } -func TestMock(t *testing.T) { - l, _ := fullNode.LightBlock(ctx, 3) - assert.Equal(t, int64(3), l.Height) -} - func TestClient_SequentialVerification(t *testing.T) { newKeys := genPrivKeys(4) newVals := newKeys.ToValidators(10, 1) @@ -216,28 +208,22 @@ func TestClient_SequentialVerification(t *testing.T) { } for _, tc := range testCases { - tc := tc - t.Run(tc.name, func(t *testing.T) { + testCase := tc + t.Run(testCase.name, func(t *testing.T) { + mockNode := mockNodeFromHeadersAndVals(testCase.otherHeaders, testCase.vals) + mockNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) c, err := light.NewClient( ctx, chainID, trustOptions, - mockp.New( - chainID, - tc.otherHeaders, - tc.vals, - ), - []provider.Provider{mockp.New( - chainID, - tc.otherHeaders, - tc.vals, - )}, + mockNode, + []provider.Provider{mockNode}, dbs.New(dbm.NewMemDB()), light.SequentialVerification(), light.Logger(log.TestingLogger()), ) - if tc.initErr { + if testCase.initErr { require.Error(t, err) return } @@ -245,11 +231,12 @@ func TestClient_SequentialVerification(t *testing.T) { require.NoError(t, err) _, err = c.VerifyLightBlockAtHeight(ctx, 3, bTime.Add(3*time.Hour)) - if tc.verifyErr { + if testCase.verifyErr { assert.Error(t, err) } else { assert.NoError(t, err) } + mockNode.AssertExpectations(t) }) } } @@ -343,20 +330,14 @@ func TestClient_SkippingVerification(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { + mockNode := mockNodeFromHeadersAndVals(tc.otherHeaders, tc.vals) + mockNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) c, err := light.NewClient( ctx, chainID, trustOptions, - mockp.New( - chainID, - tc.otherHeaders, - tc.vals, - ), - []provider.Provider{mockp.New( - chainID, - tc.otherHeaders, - tc.vals, - )}, + mockNode, + []provider.Provider{mockNode}, dbs.New(dbm.NewMemDB()), light.SkippingVerification(light.DefaultTrustLevel), light.Logger(log.TestingLogger()), @@ -382,8 +363,23 @@ func TestClient_SkippingVerification(t *testing.T) { // start from a large light block to make sure that the pivot height doesn't select a height outside // the appropriate range func TestClientLargeBisectionVerification(t *testing.T) { - veryLargeFullNode := mockp.New(genMockNode(chainID, 100, 3, 0, bTime)) - trustedLightBlock, err := veryLargeFullNode.LightBlock(ctx, 5) + numBlocks := int64(300) + mockHeaders, mockVals, _ := genLightBlocksWithKeys(chainID, numBlocks, 101, 2, bTime) + + lastBlock := &types.LightBlock{SignedHeader: mockHeaders[numBlocks], ValidatorSet: mockVals[numBlocks]} + mockNode := &provider_mocks.Provider{} + mockNode.On("LightBlock", mock.Anything, numBlocks). + Return(lastBlock, nil) + + mockNode.On("LightBlock", mock.Anything, int64(200)). + Return(&types.LightBlock{SignedHeader: mockHeaders[200], ValidatorSet: mockVals[200]}, nil) + + mockNode.On("LightBlock", mock.Anything, int64(256)). + Return(&types.LightBlock{SignedHeader: mockHeaders[256], ValidatorSet: mockVals[256]}, nil) + + mockNode.On("LightBlock", mock.Anything, int64(0)).Return(lastBlock, nil) + + trustedLightBlock, err := mockNode.LightBlock(ctx, int64(200)) require.NoError(t, err) c, err := light.NewClient( ctx, @@ -393,20 +389,25 @@ func TestClientLargeBisectionVerification(t *testing.T) { Height: trustedLightBlock.Height, Hash: trustedLightBlock.Hash(), }, - veryLargeFullNode, - []provider.Provider{veryLargeFullNode}, + mockNode, + []provider.Provider{mockNode}, dbs.New(dbm.NewMemDB()), light.SkippingVerification(light.DefaultTrustLevel), ) require.NoError(t, err) - h, err := c.Update(ctx, bTime.Add(100*time.Minute)) + h, err := c.Update(ctx, bTime.Add(300*time.Minute)) assert.NoError(t, err) - h2, err := veryLargeFullNode.LightBlock(ctx, 100) + height, err := c.LastTrustedHeight() + require.NoError(t, err) + require.Equal(t, numBlocks, height) + h2, err := mockNode.LightBlock(ctx, numBlocks) require.NoError(t, err) assert.Equal(t, h, h2) + mockNode.AssertExpectations(t) } func TestClientBisectionBetweenTrustedHeaders(t *testing.T) { + mockFullNode := mockNodeFromHeadersAndVals(headerSet, valSet) c, err := light.NewClient( ctx, chainID, @@ -415,8 +416,8 @@ func TestClientBisectionBetweenTrustedHeaders(t *testing.T) { Height: 1, Hash: h1.Hash(), }, - fullNode, - []provider.Provider{fullNode}, + mockFullNode, + []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), light.SkippingVerification(light.DefaultTrustLevel), ) @@ -432,15 +433,18 @@ func TestClientBisectionBetweenTrustedHeaders(t *testing.T) { // verify using bisection the light block between the two trusted light blocks _, err = c.VerifyLightBlockAtHeight(ctx, 2, bTime.Add(1*time.Hour)) assert.NoError(t, err) + mockFullNode.AssertExpectations(t) } func TestClient_Cleanup(t *testing.T) { + mockFullNode := &provider_mocks.Provider{} + mockFullNode.On("LightBlock", mock.Anything, int64(1)).Return(l1, nil) c, err := light.NewClient( ctx, chainID, trustOptions, - fullNode, - []provider.Provider{fullNode}, + mockFullNode, + []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -455,12 +459,14 @@ func TestClient_Cleanup(t *testing.T) { l, err := c.TrustedLightBlock(1) assert.Error(t, err) assert.Nil(t, l) + mockFullNode.AssertExpectations(t) } // trustedHeader.Height == options.Height func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { // 1. options.Hash == trustedHeader.Hash - { + t.Run("hashes should match", func(t *testing.T) { + mockNode := &provider_mocks.Provider{} trustedStore := dbs.New(dbm.NewMemDB()) err := trustedStore.SaveLightBlock(l1) require.NoError(t, err) @@ -469,8 +475,8 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { ctx, chainID, trustOptions, - fullNode, - []provider.Provider{fullNode}, + mockNode, + []provider.Provider{mockNode}, trustedStore, light.Logger(log.TestingLogger()), ) @@ -481,10 +487,11 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { assert.NotNil(t, l) assert.Equal(t, l.Hash(), h1.Hash()) assert.Equal(t, l.ValidatorSet.Hash(), h1.ValidatorsHash.Bytes()) - } + mockNode.AssertExpectations(t) + }) // 2. options.Hash != trustedHeader.Hash - { + t.Run("hashes should not match", func(t *testing.T) { trustedStore := dbs.New(dbm.NewMemDB()) err := trustedStore.SaveLightBlock(l1) require.NoError(t, err) @@ -492,15 +499,7 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { // header1 != h1 header1 := keys.GenSignedHeader(chainID, 1, bTime.Add(1*time.Hour), nil, vals, vals, hash("app_hash"), hash("cons_hash"), hash("results_hash"), 0, len(keys)) - - primary := mockp.New( - chainID, - map[int64]*types.SignedHeader{ - // trusted header - 1: header1, - }, - valSet, - ) + mockNode := &provider_mocks.Provider{} c, err := light.NewClient( ctx, @@ -510,8 +509,8 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { Height: 1, Hash: header1.Hash(), }, - primary, - []provider.Provider{primary}, + mockNode, + []provider.Provider{mockNode}, trustedStore, light.Logger(log.TestingLogger()), ) @@ -524,16 +523,21 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { assert.Equal(t, l.Hash(), l1.Hash()) assert.NoError(t, l.ValidateBasic(chainID)) } - } + mockNode.AssertExpectations(t) + }) } func TestClient_Update(t *testing.T) { + mockFullNode := &provider_mocks.Provider{} + mockFullNode.On("LightBlock", mock.Anything, int64(0)).Return(l3, nil) + mockFullNode.On("LightBlock", mock.Anything, int64(1)).Return(l1, nil) + mockFullNode.On("LightBlock", mock.Anything, int64(3)).Return(l3, nil) c, err := light.NewClient( ctx, chainID, trustOptions, - fullNode, - []provider.Provider{fullNode}, + mockFullNode, + []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -546,15 +550,19 @@ func TestClient_Update(t *testing.T) { assert.EqualValues(t, 3, l.Height) assert.NoError(t, l.ValidateBasic(chainID)) } + mockFullNode.AssertExpectations(t) } func TestClient_Concurrency(t *testing.T) { + mockFullNode := &provider_mocks.Provider{} + mockFullNode.On("LightBlock", mock.Anything, int64(2)).Return(l2, nil) + mockFullNode.On("LightBlock", mock.Anything, int64(1)).Return(l1, nil) c, err := light.NewClient( ctx, chainID, trustOptions, - fullNode, - []provider.Provider{fullNode}, + mockFullNode, + []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -587,15 +595,20 @@ func TestClient_Concurrency(t *testing.T) { } wg.Wait() + mockFullNode.AssertExpectations(t) } func TestClient_AddProviders(t *testing.T) { + mockFullNode := mockNodeFromHeadersAndVals(map[int64]*types.SignedHeader{ + 1: h1, + 2: h2, + }, valSet) c, err := light.NewClient( ctx, chainID, trustOptions, - fullNode, - []provider.Provider{fullNode}, + mockFullNode, + []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -610,22 +623,28 @@ func TestClient_AddProviders(t *testing.T) { }() // NOTE: the light client doesn't check uniqueness of providers - c.AddProvider(fullNode) + c.AddProvider(mockFullNode) require.Len(t, c.Witnesses(), 2) select { case <-closeCh: case <-time.After(5 * time.Second): t.Fatal("concurent light block verification failed to finish in 5s") } + mockFullNode.AssertExpectations(t) } func TestClientReplacesPrimaryWithWitnessIfPrimaryIsUnavailable(t *testing.T) { + mockFullNode := &provider_mocks.Provider{} + mockFullNode.On("LightBlock", mock.Anything, mock.Anything).Return(l1, nil) + + mockDeadNode := &provider_mocks.Provider{} + mockDeadNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrNoResponse) c, err := light.NewClient( ctx, chainID, trustOptions, - deadNode, - []provider.Provider{fullNode, fullNode}, + mockDeadNode, + []provider.Provider{mockFullNode, mockFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -635,16 +654,25 @@ func TestClientReplacesPrimaryWithWitnessIfPrimaryIsUnavailable(t *testing.T) { require.NoError(t, err) // the primary should no longer be the deadNode - assert.NotEqual(t, c.Primary(), deadNode) + assert.NotEqual(t, c.Primary(), mockDeadNode) // we should still have the dead node as a witness because it // hasn't repeatedly been unresponsive yet assert.Equal(t, 2, len(c.Witnesses())) + mockDeadNode.AssertExpectations(t) + mockFullNode.AssertExpectations(t) } func TestClient_BackwardsVerification(t *testing.T) { { - trustHeader, _ := largeFullNode.LightBlock(ctx, 6) + headers, vals, _ := genLightBlocksWithKeys(chainID, 9, 3, 0, bTime) + delete(headers, 1) + delete(headers, 2) + delete(vals, 1) + delete(vals, 2) + mockLargeFullNode := mockNodeFromHeadersAndVals(headers, vals) + trustHeader, _ := mockLargeFullNode.LightBlock(ctx, 6) + c, err := light.NewClient( ctx, chainID, @@ -653,8 +681,8 @@ func TestClient_BackwardsVerification(t *testing.T) { Height: trustHeader.Height, Hash: trustHeader.Hash(), }, - largeFullNode, - []provider.Provider{largeFullNode}, + mockLargeFullNode, + []provider.Provider{mockLargeFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -692,41 +720,36 @@ func TestClient_BackwardsVerification(t *testing.T) { // so expect error _, err = c.VerifyLightBlockAtHeight(ctx, 8, bTime.Add(12*time.Minute)) assert.Error(t, err) + mockLargeFullNode.AssertExpectations(t) } { testCases := []struct { - provider provider.Provider + headers map[int64]*types.SignedHeader + vals map[int64]*types.ValidatorSet }{ { // 7) provides incorrect height - mockp.New( - chainID, - map[int64]*types.SignedHeader{ - 1: h1, - 2: keys.GenSignedHeader(chainID, 1, bTime.Add(30*time.Minute), nil, vals, vals, - hash("app_hash"), hash("cons_hash"), hash("results_hash"), 0, len(keys)), - 3: h3, - }, - valSet, - ), + headers: map[int64]*types.SignedHeader{ + 2: keys.GenSignedHeader(chainID, 1, bTime.Add(30*time.Minute), nil, vals, vals, + hash("app_hash"), hash("cons_hash"), hash("results_hash"), 0, len(keys)), + 3: h3, + }, + vals: valSet, }, { // 8) provides incorrect hash - mockp.New( - chainID, - map[int64]*types.SignedHeader{ - 1: h1, - 2: keys.GenSignedHeader(chainID, 2, bTime.Add(30*time.Minute), nil, vals, vals, - hash("app_hash2"), hash("cons_hash23"), hash("results_hash30"), 0, len(keys)), - 3: h3, - }, - valSet, - ), + headers: map[int64]*types.SignedHeader{ + 2: keys.GenSignedHeader(chainID, 2, bTime.Add(30*time.Minute), nil, vals, vals, + hash("app_hash2"), hash("cons_hash23"), hash("results_hash30"), 0, len(keys)), + 3: h3, + }, + vals: valSet, }, } for idx, tc := range testCases { + mockNode := mockNodeFromHeadersAndVals(tc.headers, tc.vals) c, err := light.NewClient( ctx, chainID, @@ -735,8 +758,8 @@ func TestClient_BackwardsVerification(t *testing.T) { Height: 3, Hash: h3.Hash(), }, - tc.provider, - []provider.Provider{tc.provider}, + mockNode, + []provider.Provider{mockNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -744,6 +767,7 @@ func TestClient_BackwardsVerification(t *testing.T) { _, err = c.VerifyLightBlockAtHeight(ctx, 2, bTime.Add(1*time.Hour).Add(1*time.Second)) assert.Error(t, err, idx) + mockNode.AssertExpectations(t) } } } @@ -753,60 +777,62 @@ func TestClient_NewClientFromTrustedStore(t *testing.T) { db := dbs.New(dbm.NewMemDB()) err := db.SaveLightBlock(l1) require.NoError(t, err) + mockNode := &provider_mocks.Provider{} c, err := light.NewClientFromTrustedStore( chainID, trustPeriod, - deadNode, - []provider.Provider{deadNode}, + mockNode, + []provider.Provider{mockNode}, db, ) require.NoError(t, err) - // 2) Check light block exists (deadNode is being used to ensure we're not getting - // it from primary) + // 2) Check light block exists h, err := c.TrustedLightBlock(1) assert.NoError(t, err) assert.EqualValues(t, l1.Height, h.Height) + mockNode.AssertExpectations(t) } func TestClientRemovesWitnessIfItSendsUsIncorrectHeader(t *testing.T) { // different headers hash then primary plus less than 1/3 signed (no fork) - badProvider1 := mockp.New( - chainID, - map[int64]*types.SignedHeader{ - 1: h1, - 2: keys.GenSignedHeaderLastBlockID(chainID, 2, bTime.Add(30*time.Minute), nil, vals, vals, - hash("app_hash2"), hash("cons_hash"), hash("results_hash"), - len(keys), len(keys), types.BlockID{Hash: h1.Hash()}), - }, - map[int64]*types.ValidatorSet{ - 1: vals, - 2: vals, - }, - ) - // header is empty - badProvider2 := mockp.New( - chainID, - map[int64]*types.SignedHeader{ - 1: h1, - 2: h2, - }, - map[int64]*types.ValidatorSet{ - 1: vals, - 2: vals, - }, - ) + headers1 := map[int64]*types.SignedHeader{ + 1: h1, + 2: keys.GenSignedHeaderLastBlockID(chainID, 2, bTime.Add(30*time.Minute), nil, vals, vals, + hash("app_hash2"), hash("cons_hash"), hash("results_hash"), + len(keys), len(keys), types.BlockID{Hash: h1.Hash()}), + } + vals1 := map[int64]*types.ValidatorSet{ + 1: vals, + 2: vals, + } + mockBadNode1 := mockNodeFromHeadersAndVals(headers1, vals1) + mockBadNode1.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) - lb1, _ := badProvider1.LightBlock(ctx, 2) + // header is empty + headers2 := map[int64]*types.SignedHeader{ + 1: h1, + 2: h2, + } + vals2 := map[int64]*types.ValidatorSet{ + 1: vals, + 2: vals, + } + mockBadNode2 := mockNodeFromHeadersAndVals(headers2, vals2) + mockBadNode2.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) + + mockFullNode := mockNodeFromHeadersAndVals(headerSet, valSet) + + lb1, _ := mockBadNode1.LightBlock(ctx, 2) require.NotEqual(t, lb1.Hash(), l1.Hash()) c, err := light.NewClient( ctx, chainID, trustOptions, - fullNode, - []provider.Provider{badProvider1, badProvider2}, + mockFullNode, + []provider.Provider{mockBadNode1, mockBadNode2}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -828,12 +854,13 @@ func TestClientRemovesWitnessIfItSendsUsIncorrectHeader(t *testing.T) { } // witness does not have a light block -> left in the list assert.EqualValues(t, 1, len(c.Witnesses())) + mockBadNode1.AssertExpectations(t) + mockBadNode2.AssertExpectations(t) } func TestClient_TrustedValidatorSet(t *testing.T) { differentVals, _ := factory.RandValidatorSet(10, 100) - badValSetNode := mockp.New( - chainID, + mockBadValSetNode := mockNodeFromHeadersAndVals( map[int64]*types.SignedHeader{ 1: h1, // 3/3 signed, but validator set at height 2 below is invalid -> witness @@ -841,21 +868,27 @@ func TestClient_TrustedValidatorSet(t *testing.T) { 2: keys.GenSignedHeaderLastBlockID(chainID, 2, bTime.Add(30*time.Minute), nil, vals, vals, hash("app_hash2"), hash("cons_hash"), hash("results_hash"), 0, len(keys), types.BlockID{Hash: h1.Hash()}), - 3: h3, }, map[int64]*types.ValidatorSet{ 1: vals, 2: differentVals, - 3: differentVals, + }) + mockFullNode := mockNodeFromHeadersAndVals( + map[int64]*types.SignedHeader{ + 1: h1, + 2: h2, }, - ) + map[int64]*types.ValidatorSet{ + 1: vals, + 2: vals, + }) c, err := light.NewClient( ctx, chainID, trustOptions, - fullNode, - []provider.Provider{badValSetNode, fullNode}, + mockFullNode, + []provider.Provider{mockBadValSetNode, mockFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) @@ -865,15 +898,29 @@ func TestClient_TrustedValidatorSet(t *testing.T) { _, err = c.VerifyLightBlockAtHeight(ctx, 2, bTime.Add(2*time.Hour).Add(1*time.Second)) assert.NoError(t, err) assert.Equal(t, 1, len(c.Witnesses())) + mockBadValSetNode.AssertExpectations(t) + mockFullNode.AssertExpectations(t) } func TestClientPrunesHeadersAndValidatorSets(t *testing.T) { + mockFullNode := mockNodeFromHeadersAndVals( + map[int64]*types.SignedHeader{ + 1: h1, + 3: h3, + 0: h3, + }, + map[int64]*types.ValidatorSet{ + 1: vals, + 3: vals, + 0: vals, + }) + c, err := light.NewClient( ctx, chainID, trustOptions, - fullNode, - []provider.Provider{fullNode}, + mockFullNode, + []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), light.PruningSize(1), @@ -888,6 +935,7 @@ func TestClientPrunesHeadersAndValidatorSets(t *testing.T) { _, err = c.TrustedLightBlock(1) assert.Error(t, err) + mockFullNode.AssertExpectations(t) } func TestClientEnsureValidHeadersAndValSets(t *testing.T) { @@ -899,86 +947,108 @@ func TestClientEnsureValidHeadersAndValSets(t *testing.T) { testCases := []struct { headers map[int64]*types.SignedHeader vals map[int64]*types.ValidatorSet - err bool + + errorToThrow error + errorHeight int64 + + err bool }{ { - headerSet, - valSet, - false, - }, - { - headerSet, - map[int64]*types.ValidatorSet{ - 1: vals, - 2: vals, - 3: nil, - }, - true, - }, - { - map[int64]*types.SignedHeader{ + headers: map[int64]*types.SignedHeader{ 1: h1, - 2: h2, - 3: nil, + 3: h3, }, - valSet, - true, + vals: map[int64]*types.ValidatorSet{ + 1: vals, + 3: vals, + }, + err: false, }, { - headerSet, - map[int64]*types.ValidatorSet{ + headers: map[int64]*types.SignedHeader{ + 1: h1, + }, + vals: map[int64]*types.ValidatorSet{ + 1: vals, + }, + errorToThrow: provider.ErrBadLightBlock{Reason: errors.New("nil header or vals")}, + errorHeight: 3, + err: true, + }, + { + headers: map[int64]*types.SignedHeader{ + 1: h1, + }, + errorToThrow: provider.ErrBadLightBlock{Reason: errors.New("nil header or vals")}, + errorHeight: 3, + vals: valSet, + err: true, + }, + { + headers: map[int64]*types.SignedHeader{ + 1: h1, + 3: h3, + }, + vals: map[int64]*types.ValidatorSet{ 1: vals, - 2: vals, 3: emptyValSet, }, - true, + err: true, }, } - for _, tc := range testCases { - badNode := mockp.New( - chainID, - tc.headers, - tc.vals, - ) - c, err := light.NewClient( - ctx, - chainID, - trustOptions, - badNode, - []provider.Provider{badNode, badNode}, - dbs.New(dbm.NewMemDB()), - ) - require.NoError(t, err) + for i, tc := range testCases { + testCase := tc + t.Run(fmt.Sprintf("case: %d", i), func(t *testing.T) { + mockBadNode := mockNodeFromHeadersAndVals(testCase.headers, testCase.vals) + if testCase.errorToThrow != nil { + mockBadNode.On("LightBlock", mock.Anything, testCase.errorHeight).Return(nil, testCase.errorToThrow) + } - _, err = c.VerifyLightBlockAtHeight(ctx, 3, bTime.Add(2*time.Hour)) - if tc.err { - assert.Error(t, err) - } else { - assert.NoError(t, err) - } + c, err := light.NewClient( + ctx, + chainID, + trustOptions, + mockBadNode, + []provider.Provider{mockBadNode, mockBadNode}, + dbs.New(dbm.NewMemDB()), + ) + require.NoError(t, err) + + _, err = c.VerifyLightBlockAtHeight(ctx, 3, bTime.Add(2*time.Hour)) + if testCase.err { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + mockBadNode.AssertExpectations(t) + }) } } func TestClientHandlesContexts(t *testing.T) { - p := mockp.New(genMockNode(chainID, 100, 10, 1, bTime)) - genBlock, err := p.LightBlock(ctx, 1) - require.NoError(t, err) + mockNode := &provider_mocks.Provider{} + mockNode.On("LightBlock", + mock.MatchedBy(func(ctx context.Context) bool { return ctx.Err() == nil }), + int64(1)).Return(l1, nil) + mockNode.On("LightBlock", + mock.MatchedBy(func(ctx context.Context) bool { return ctx.Err() == context.DeadlineExceeded }), + mock.Anything).Return(nil, context.DeadlineExceeded) + + mockNode.On("LightBlock", + mock.MatchedBy(func(ctx context.Context) bool { return ctx.Err() == context.Canceled }), + mock.Anything).Return(nil, context.Canceled) // instantiate the light client with a timeout - ctxTimeOut, cancel := context.WithTimeout(ctx, 10*time.Millisecond) + ctxTimeOut, cancel := context.WithTimeout(ctx, 1*time.Nanosecond) defer cancel() - _, err = light.NewClient( + _, err := light.NewClient( ctxTimeOut, chainID, - light.TrustOptions{ - Period: 24 * time.Hour, - Height: 1, - Hash: genBlock.Hash(), - }, - p, - []provider.Provider{p, p}, + trustOptions, + mockNode, + []provider.Provider{mockNode, mockNode}, dbs.New(dbm.NewMemDB()), ) require.Error(t, ctxTimeOut.Err()) @@ -989,19 +1059,15 @@ func TestClientHandlesContexts(t *testing.T) { c, err := light.NewClient( ctx, chainID, - light.TrustOptions{ - Period: 24 * time.Hour, - Height: 1, - Hash: genBlock.Hash(), - }, - p, - []provider.Provider{p, p}, + trustOptions, + mockNode, + []provider.Provider{mockNode, mockNode}, dbs.New(dbm.NewMemDB()), ) require.NoError(t, err) // verify a block with a timeout - ctxTimeOutBlock, cancel := context.WithTimeout(ctx, 10*time.Millisecond) + ctxTimeOutBlock, cancel := context.WithTimeout(ctx, 1*time.Nanosecond) defer cancel() _, err = c.VerifyLightBlockAtHeight(ctxTimeOutBlock, 100, bTime.Add(100*time.Minute)) require.Error(t, ctxTimeOutBlock.Err()) @@ -1010,11 +1076,11 @@ func TestClientHandlesContexts(t *testing.T) { // verify a block with a cancel ctxCancel, cancel := context.WithCancel(ctx) - defer cancel() - time.AfterFunc(10*time.Millisecond, cancel) + cancel() _, err = c.VerifyLightBlockAtHeight(ctxCancel, 100, bTime.Add(100*time.Minute)) require.Error(t, ctxCancel.Err()) require.Error(t, err) require.True(t, errors.Is(err, context.Canceled)) + mockNode.AssertExpectations(t) } diff --git a/light/detector_test.go b/light/detector_test.go index 48efd4130..0bf96ace6 100644 --- a/light/detector_test.go +++ b/light/detector_test.go @@ -1,10 +1,12 @@ package light_test import ( + "bytes" "testing" "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" dbm "github.com/tendermint/tm-db" @@ -12,7 +14,7 @@ import ( "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/light" "github.com/tendermint/tendermint/light/provider" - mockp "github.com/tendermint/tendermint/light/provider/mock" + provider_mocks "github.com/tendermint/tendermint/light/provider/mocks" dbs "github.com/tendermint/tendermint/light/store/db" "github.com/tendermint/tendermint/types" ) @@ -20,15 +22,15 @@ import ( func TestLightClientAttackEvidence_Lunatic(t *testing.T) { // primary performs a lunatic attack var ( - latestHeight = int64(10) + latestHeight = int64(3) valSize = 5 - divergenceHeight = int64(6) + divergenceHeight = int64(2) primaryHeaders = make(map[int64]*types.SignedHeader, latestHeight) primaryValidators = make(map[int64]*types.ValidatorSet, latestHeight) ) - witnessHeaders, witnessValidators, chainKeys := genMockNodeWithKeys(chainID, latestHeight, valSize, 2, bTime) - witness := mockp.New(chainID, witnessHeaders, witnessValidators) + witnessHeaders, witnessValidators, chainKeys := genLightBlocksWithKeys(chainID, latestHeight, valSize, 2, bTime) + forgedKeys := chainKeys[divergenceHeight-1].ChangeKeys(3) // we change 3 out of the 5 validators (still 2/5 remain) forgedVals := forgedKeys.ToValidators(2, 0) @@ -42,7 +44,38 @@ func TestLightClientAttackEvidence_Lunatic(t *testing.T) { nil, forgedVals, forgedVals, hash("app_hash"), hash("cons_hash"), hash("results_hash"), 0, len(forgedKeys)) primaryValidators[height] = forgedVals } - primary := mockp.New(chainID, primaryHeaders, primaryValidators) + + // never called, delete it to make mockery asserts pass + delete(witnessHeaders, 2) + delete(primaryHeaders, 2) + + mockWitness := mockNodeFromHeadersAndVals(witnessHeaders, witnessValidators) + mockPrimary := mockNodeFromHeadersAndVals(primaryHeaders, primaryValidators) + + mockWitness.On("ReportEvidence", mock.Anything, mock.MatchedBy(func(evidence types.Evidence) bool { + evAgainstPrimary := &types.LightClientAttackEvidence{ + // after the divergence height the valset doesn't change so we expect the evidence to be for the latest height + ConflictingBlock: &types.LightBlock{ + SignedHeader: primaryHeaders[latestHeight], + ValidatorSet: primaryValidators[latestHeight], + }, + CommonHeight: 1, + } + return bytes.Equal(evidence.Hash(), evAgainstPrimary.Hash()) + })).Return(nil) + + mockPrimary.On("ReportEvidence", mock.Anything, mock.MatchedBy(func(evidence types.Evidence) bool { + evAgainstWitness := &types.LightClientAttackEvidence{ + // when forming evidence against witness we learn that the canonical chain continued to change validator sets + // hence the conflicting block is at 7 + ConflictingBlock: &types.LightBlock{ + SignedHeader: witnessHeaders[divergenceHeight+1], + ValidatorSet: witnessValidators[divergenceHeight+1], + }, + CommonHeight: divergenceHeight - 1, + } + return bytes.Equal(evidence.Hash(), evAgainstWitness.Hash()) + })).Return(nil) c, err := light.NewClient( ctx, @@ -52,121 +85,134 @@ func TestLightClientAttackEvidence_Lunatic(t *testing.T) { Height: 1, Hash: primaryHeaders[1].Hash(), }, - primary, - []provider.Provider{witness}, + mockPrimary, + []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) require.NoError(t, err) // Check verification returns an error. - _, err = c.VerifyLightBlockAtHeight(ctx, 10, bTime.Add(1*time.Hour)) + _, err = c.VerifyLightBlockAtHeight(ctx, latestHeight, bTime.Add(1*time.Hour)) if assert.Error(t, err) { assert.Equal(t, light.ErrLightClientAttack, err) } - // Check evidence was sent to both full nodes. - evAgainstPrimary := &types.LightClientAttackEvidence{ - // after the divergence height the valset doesn't change so we expect the evidence to be for height 10 - ConflictingBlock: &types.LightBlock{ - SignedHeader: primaryHeaders[10], - ValidatorSet: primaryValidators[10], - }, - CommonHeight: 4, - } - assert.True(t, witness.HasEvidence(evAgainstPrimary)) - - evAgainstWitness := &types.LightClientAttackEvidence{ - // when forming evidence against witness we learn that the canonical chain continued to change validator sets - // hence the conflicting block is at 7 - ConflictingBlock: &types.LightBlock{ - SignedHeader: witnessHeaders[7], - ValidatorSet: witnessValidators[7], - }, - CommonHeight: 4, - } - assert.True(t, primary.HasEvidence(evAgainstWitness)) + mockWitness.AssertExpectations(t) + mockPrimary.AssertExpectations(t) } func TestLightClientAttackEvidence_Equivocation(t *testing.T) { - verificationOptions := map[string]light.Option{ - "sequential": light.SequentialVerification(), - "skipping": light.SkippingVerification(light.DefaultTrustLevel), + cases := []struct { + name string + lightOption light.Option + unusedWitnessBlockHeights []int64 + unusedPrimaryBlockHeights []int64 + latestHeight int64 + divergenceHeight int64 + }{ + { + name: "sequential", + lightOption: light.SequentialVerification(), + unusedWitnessBlockHeights: []int64{4, 6}, + latestHeight: int64(5), + divergenceHeight: int64(3), + }, + { + name: "skipping", + lightOption: light.SkippingVerification(light.DefaultTrustLevel), + unusedWitnessBlockHeights: []int64{2, 4, 6}, + unusedPrimaryBlockHeights: []int64{2, 4, 6}, + latestHeight: int64(5), + divergenceHeight: int64(3), + }, } - for s, verificationOption := range verificationOptions { - t.Log("==> verification", s) - - // primary performs an equivocation attack - var ( - latestHeight = int64(10) - valSize = 5 - divergenceHeight = int64(6) - primaryHeaders = make(map[int64]*types.SignedHeader, latestHeight) - primaryValidators = make(map[int64]*types.ValidatorSet, latestHeight) - ) - // validators don't change in this network (however we still use a map just for convenience) - witnessHeaders, witnessValidators, chainKeys := genMockNodeWithKeys(chainID, latestHeight+2, valSize, 2, bTime) - witness := mockp.New(chainID, witnessHeaders, witnessValidators) - - for height := int64(1); height <= latestHeight; height++ { - if height < divergenceHeight { - primaryHeaders[height] = witnessHeaders[height] + for _, tc := range cases { + testCase := tc + t.Run(testCase.name, func(t *testing.T) { + // primary performs an equivocation attack + var ( + valSize = 5 + primaryHeaders = make(map[int64]*types.SignedHeader, testCase.latestHeight) + // validators don't change in this network (however we still use a map just for convenience) + primaryValidators = make(map[int64]*types.ValidatorSet, testCase.latestHeight) + ) + witnessHeaders, witnessValidators, chainKeys := genLightBlocksWithKeys(chainID, + testCase.latestHeight+1, valSize, 2, bTime) + for height := int64(1); height <= testCase.latestHeight; height++ { + if height < testCase.divergenceHeight { + primaryHeaders[height] = witnessHeaders[height] + primaryValidators[height] = witnessValidators[height] + continue + } + // we don't have a network partition so we will make 4/5 (greater than 2/3) malicious and vote again for + // a different block (which we do by adding txs) + primaryHeaders[height] = chainKeys[height].GenSignedHeader(chainID, height, + bTime.Add(time.Duration(height)*time.Minute), []types.Tx{[]byte("abcd")}, + witnessValidators[height], witnessValidators[height+1], hash("app_hash"), + hash("cons_hash"), hash("results_hash"), 0, len(chainKeys[height])-1) primaryValidators[height] = witnessValidators[height] - continue } - // we don't have a network partition so we will make 4/5 (greater than 2/3) malicious and vote again for - // a different block (which we do by adding txs) - primaryHeaders[height] = chainKeys[height].GenSignedHeader(chainID, height, - bTime.Add(time.Duration(height)*time.Minute), []types.Tx{[]byte("abcd")}, - witnessValidators[height], witnessValidators[height+1], hash("app_hash"), - hash("cons_hash"), hash("results_hash"), 0, len(chainKeys[height])-1) - primaryValidators[height] = witnessValidators[height] - } - primary := mockp.New(chainID, primaryHeaders, primaryValidators) - c, err := light.NewClient( - ctx, - chainID, - light.TrustOptions{ - Period: 4 * time.Hour, - Height: 1, - Hash: primaryHeaders[1].Hash(), - }, - primary, - []provider.Provider{witness}, - dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), - verificationOption, - ) - require.NoError(t, err) + for _, height := range testCase.unusedWitnessBlockHeights { + delete(witnessHeaders, height) + } + mockWitness := mockNodeFromHeadersAndVals(witnessHeaders, witnessValidators) + for _, height := range testCase.unusedPrimaryBlockHeights { + delete(primaryHeaders, height) + } + mockPrimary := mockNodeFromHeadersAndVals(primaryHeaders, primaryValidators) - // Check verification returns an error. - _, err = c.VerifyLightBlockAtHeight(ctx, 10, bTime.Add(1*time.Hour)) - if assert.Error(t, err) { - assert.Equal(t, light.ErrLightClientAttack, err) - } + // Check evidence was sent to both full nodes. + // Common height should be set to the height of the divergent header in the instance + // of an equivocation attack and the validator sets are the same as what the witness has + mockWitness.On("ReportEvidence", mock.Anything, mock.MatchedBy(func(evidence types.Evidence) bool { + evAgainstPrimary := &types.LightClientAttackEvidence{ + ConflictingBlock: &types.LightBlock{ + SignedHeader: primaryHeaders[testCase.divergenceHeight], + ValidatorSet: primaryValidators[testCase.divergenceHeight], + }, + CommonHeight: testCase.divergenceHeight, + } + return bytes.Equal(evidence.Hash(), evAgainstPrimary.Hash()) + })).Return(nil) + mockPrimary.On("ReportEvidence", mock.Anything, mock.MatchedBy(func(evidence types.Evidence) bool { + evAgainstWitness := &types.LightClientAttackEvidence{ + ConflictingBlock: &types.LightBlock{ + SignedHeader: witnessHeaders[testCase.divergenceHeight], + ValidatorSet: witnessValidators[testCase.divergenceHeight], + }, + CommonHeight: testCase.divergenceHeight, + } + return bytes.Equal(evidence.Hash(), evAgainstWitness.Hash()) + })).Return(nil) - // Check evidence was sent to both full nodes. - // Common height should be set to the height of the divergent header in the instance - // of an equivocation attack and the validator sets are the same as what the witness has - evAgainstPrimary := &types.LightClientAttackEvidence{ - ConflictingBlock: &types.LightBlock{ - SignedHeader: primaryHeaders[divergenceHeight], - ValidatorSet: primaryValidators[divergenceHeight], - }, - CommonHeight: divergenceHeight, - } - assert.True(t, witness.HasEvidence(evAgainstPrimary)) + c, err := light.NewClient( + ctx, + chainID, + light.TrustOptions{ + Period: 4 * time.Hour, + Height: 1, + Hash: primaryHeaders[1].Hash(), + }, + mockPrimary, + []provider.Provider{mockWitness}, + dbs.New(dbm.NewMemDB()), + light.Logger(log.TestingLogger()), + testCase.lightOption, + ) + require.NoError(t, err) - evAgainstWitness := &types.LightClientAttackEvidence{ - ConflictingBlock: &types.LightBlock{ - SignedHeader: witnessHeaders[divergenceHeight], - ValidatorSet: witnessValidators[divergenceHeight], - }, - CommonHeight: divergenceHeight, - } - assert.True(t, primary.HasEvidence(evAgainstWitness)) + // Check verification returns an error. + _, err = c.VerifyLightBlockAtHeight(ctx, testCase.latestHeight, bTime.Add(300*time.Second)) + if assert.Error(t, err) { + assert.Equal(t, light.ErrLightClientAttack, err) + } + + mockWitness.AssertExpectations(t) + mockPrimary.AssertExpectations(t) + }) } } @@ -182,7 +228,10 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { primaryValidators = make(map[int64]*types.ValidatorSet, forgedHeight) ) - witnessHeaders, witnessValidators, chainKeys := genMockNodeWithKeys(chainID, latestHeight, valSize, 2, bTime) + witnessHeaders, witnessValidators, chainKeys := genLightBlocksWithKeys(chainID, latestHeight, valSize, 2, bTime) + for _, unusedHeader := range []int64{3, 5, 6, 8} { + delete(witnessHeaders, unusedHeader) + } // primary has the exact same headers except it forges one extra header in the future using keys from 2/5ths of // the validators @@ -190,6 +239,9 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { primaryHeaders[h] = witnessHeaders[h] primaryValidators[h] = witnessValidators[h] } + for _, unusedHeader := range []int64{3, 5, 6, 8} { + delete(primaryHeaders, unusedHeader) + } forgedKeys := chainKeys[latestHeight].ChangeKeys(3) // we change 3 out of the 5 validators (still 2/5 remain) primaryValidators[forgedHeight] = forgedKeys.ToValidators(2, 0) primaryHeaders[forgedHeight] = forgedKeys.GenSignedHeader( @@ -204,15 +256,36 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { hash("results_hash"), 0, len(forgedKeys), ) + mockPrimary := mockNodeFromHeadersAndVals(primaryHeaders, primaryValidators) + lastBlock, _ := mockPrimary.LightBlock(ctx, forgedHeight) + mockPrimary.On("LightBlock", mock.Anything, int64(0)).Return(lastBlock, nil) + mockPrimary.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) - witness := mockp.New(chainID, witnessHeaders, witnessValidators) - primary := mockp.New(chainID, primaryHeaders, primaryValidators) + /* + for _, unusedHeader := range []int64{3, 5, 6, 8} { + delete(witnessHeaders, unusedHeader) + } + */ + mockWitness := mockNodeFromHeadersAndVals(witnessHeaders, witnessValidators) + lastBlock, _ = mockWitness.LightBlock(ctx, latestHeight) + mockWitness.On("LightBlock", mock.Anything, int64(0)).Return(lastBlock, nil).Once() + mockWitness.On("LightBlock", mock.Anything, int64(12)).Return(nil, provider.ErrHeightTooHigh) - laggingWitness := witness.Copy("laggingWitness") + mockWitness.On("ReportEvidence", mock.Anything, mock.MatchedBy(func(evidence types.Evidence) bool { + // Check evidence was sent to the witness against the full node + evAgainstPrimary := &types.LightClientAttackEvidence{ + ConflictingBlock: &types.LightBlock{ + SignedHeader: primaryHeaders[forgedHeight], + ValidatorSet: primaryValidators[forgedHeight], + }, + CommonHeight: latestHeight, + } + return bytes.Equal(evidence.Hash(), evAgainstPrimary.Hash()) + })).Return(nil).Twice() // In order to perform the attack, the primary needs at least one accomplice as a witness to also // send the forged block - accomplice := primary + accomplice := mockPrimary c, err := light.NewClient( ctx, @@ -222,8 +295,8 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { Height: 1, Hash: primaryHeaders[1].Hash(), }, - primary, - []provider.Provider{witness, accomplice}, + mockPrimary, + []provider.Provider{mockWitness, accomplice}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), light.MaxClockDrift(1*time.Second), @@ -251,7 +324,7 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { } go func() { time.Sleep(2 * time.Second) - witness.AddLightBlock(newLb) + mockWitness.On("LightBlock", mock.Anything, int64(0)).Return(newLb, nil) }() // Now assert that verification returns an error. We craft the light clients time to be a little ahead of the chain @@ -261,26 +334,19 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { assert.Equal(t, light.ErrLightClientAttack, err) } - // Check evidence was sent to the witness against the full node - evAgainstPrimary := &types.LightClientAttackEvidence{ - ConflictingBlock: &types.LightBlock{ - SignedHeader: primaryHeaders[forgedHeight], - ValidatorSet: primaryValidators[forgedHeight], - }, - CommonHeight: latestHeight, - } - assert.True(t, witness.HasEvidence(evAgainstPrimary)) - // We attempt the same call but now the supporting witness has a block which should // immediately conflict in time with the primary _, err = c.VerifyLightBlockAtHeight(ctx, forgedHeight, bTime.Add(time.Duration(forgedHeight)*time.Minute)) if assert.Error(t, err) { assert.Equal(t, light.ErrLightClientAttack, err) } - assert.True(t, witness.HasEvidence(evAgainstPrimary)) // Lastly we test the unfortunate case where the light clients supporting witness doesn't update // in enough time + mockLaggingWitness := mockNodeFromHeadersAndVals(witnessHeaders, witnessValidators) + mockLaggingWitness.On("LightBlock", mock.Anything, int64(12)).Return(nil, provider.ErrHeightTooHigh) + lastBlock, _ = mockLaggingWitness.LightBlock(ctx, latestHeight) + mockLaggingWitness.On("LightBlock", mock.Anything, int64(0)).Return(lastBlock, nil) c, err = light.NewClient( ctx, chainID, @@ -289,8 +355,8 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { Height: 1, Hash: primaryHeaders[1].Hash(), }, - primary, - []provider.Provider{laggingWitness, accomplice}, + mockPrimary, + []provider.Provider{mockLaggingWitness, accomplice}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), light.MaxClockDrift(1*time.Second), @@ -300,17 +366,20 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { _, err = c.Update(ctx, bTime.Add(time.Duration(forgedHeight)*time.Minute)) assert.NoError(t, err) - + mockPrimary.AssertExpectations(t) + mockWitness.AssertExpectations(t) } // 1. Different nodes therefore a divergent header is produced. // => light client returns an error upon creation because primary and witness // have a different view. func TestClientDivergentTraces1(t *testing.T) { - primary := mockp.New(genMockNode(chainID, 10, 5, 2, bTime)) - firstBlock, err := primary.LightBlock(ctx, 1) + headers, vals, _ := genLightBlocksWithKeys(chainID, 1, 5, 2, bTime) + mockPrimary := mockNodeFromHeadersAndVals(headers, vals) + firstBlock, err := mockPrimary.LightBlock(ctx, 1) require.NoError(t, err) - witness := mockp.New(genMockNode(chainID, 10, 5, 2, bTime)) + headers, vals, _ = genLightBlocksWithKeys(chainID, 1, 5, 2, bTime) + mockWitness := mockNodeFromHeadersAndVals(headers, vals) _, err = light.NewClient( ctx, @@ -320,20 +389,25 @@ func TestClientDivergentTraces1(t *testing.T) { Hash: firstBlock.Hash(), Period: 4 * time.Hour, }, - primary, - []provider.Provider{witness}, + mockPrimary, + []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) require.Error(t, err) assert.Contains(t, err.Error(), "does not match primary") + mockWitness.AssertExpectations(t) + mockPrimary.AssertExpectations(t) } // 2. Two out of three nodes don't respond but the third has a header that matches // => verification should be successful and all the witnesses should remain func TestClientDivergentTraces2(t *testing.T) { - primary := mockp.New(genMockNode(chainID, 10, 5, 2, bTime)) - firstBlock, err := primary.LightBlock(ctx, 1) + headers, vals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) + mockPrimaryNode := mockNodeFromHeadersAndVals(headers, vals) + mockDeadNode := &provider_mocks.Provider{} + mockDeadNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrNoResponse) + firstBlock, err := mockPrimaryNode.LightBlock(ctx, 1) require.NoError(t, err) c, err := light.NewClient( ctx, @@ -343,31 +417,35 @@ func TestClientDivergentTraces2(t *testing.T) { Hash: firstBlock.Hash(), Period: 4 * time.Hour, }, - primary, - []provider.Provider{deadNode, deadNode, primary}, + mockPrimaryNode, + []provider.Provider{mockDeadNode, mockDeadNode, mockPrimaryNode}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) require.NoError(t, err) - _, err = c.VerifyLightBlockAtHeight(ctx, 10, bTime.Add(1*time.Hour)) + _, err = c.VerifyLightBlockAtHeight(ctx, 2, bTime.Add(1*time.Hour)) assert.NoError(t, err) assert.Equal(t, 3, len(c.Witnesses())) + mockDeadNode.AssertExpectations(t) + mockPrimaryNode.AssertExpectations(t) } // 3. witness has the same first header, but different second header // => creation should succeed, but the verification should fail +//nolint: dupl func TestClientDivergentTraces3(t *testing.T) { - _, primaryHeaders, primaryVals := genMockNode(chainID, 10, 5, 2, bTime) - primary := mockp.New(chainID, primaryHeaders, primaryVals) + // + primaryHeaders, primaryVals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) + mockPrimary := mockNodeFromHeadersAndVals(primaryHeaders, primaryVals) - firstBlock, err := primary.LightBlock(ctx, 1) + firstBlock, err := mockPrimary.LightBlock(ctx, 1) require.NoError(t, err) - _, mockHeaders, mockVals := genMockNode(chainID, 10, 5, 2, bTime) + mockHeaders, mockVals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) mockHeaders[1] = primaryHeaders[1] mockVals[1] = primaryVals[1] - witness := mockp.New(chainID, mockHeaders, mockVals) + mockWitness := mockNodeFromHeadersAndVals(mockHeaders, mockVals) c, err := light.NewClient( ctx, @@ -377,33 +455,35 @@ func TestClientDivergentTraces3(t *testing.T) { Hash: firstBlock.Hash(), Period: 4 * time.Hour, }, - primary, - []provider.Provider{witness}, + mockPrimary, + []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) require.NoError(t, err) - _, err = c.VerifyLightBlockAtHeight(ctx, 10, bTime.Add(1*time.Hour)) + _, err = c.VerifyLightBlockAtHeight(ctx, 2, bTime.Add(1*time.Hour)) assert.Error(t, err) assert.Equal(t, 1, len(c.Witnesses())) + mockWitness.AssertExpectations(t) + mockPrimary.AssertExpectations(t) } // 4. Witness has a divergent header but can not produce a valid trace to back it up. // It should be ignored +//nolint: dupl func TestClientDivergentTraces4(t *testing.T) { - _, primaryHeaders, primaryVals := genMockNode(chainID, 10, 5, 2, bTime) - primary := mockp.New(chainID, primaryHeaders, primaryVals) + // + primaryHeaders, primaryVals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) + mockPrimary := mockNodeFromHeadersAndVals(primaryHeaders, primaryVals) - firstBlock, err := primary.LightBlock(ctx, 1) + firstBlock, err := mockPrimary.LightBlock(ctx, 1) require.NoError(t, err) - _, mockHeaders, mockVals := genMockNode(chainID, 10, 5, 2, bTime) - witness := primary.Copy("witness") - witness.AddLightBlock(&types.LightBlock{ - SignedHeader: mockHeaders[10], - ValidatorSet: mockVals[10], - }) + witnessHeaders, witnessVals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) + primaryHeaders[2] = witnessHeaders[2] + primaryVals[2] = witnessVals[2] + mockWitness := mockNodeFromHeadersAndVals(primaryHeaders, primaryVals) c, err := light.NewClient( ctx, @@ -413,14 +493,16 @@ func TestClientDivergentTraces4(t *testing.T) { Hash: firstBlock.Hash(), Period: 4 * time.Hour, }, - primary, - []provider.Provider{witness}, + mockPrimary, + []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), light.Logger(log.TestingLogger()), ) require.NoError(t, err) - _, err = c.VerifyLightBlockAtHeight(ctx, 10, bTime.Add(1*time.Hour)) + _, err = c.VerifyLightBlockAtHeight(ctx, 2, bTime.Add(1*time.Hour)) assert.Error(t, err) assert.Equal(t, 1, len(c.Witnesses())) + mockWitness.AssertExpectations(t) + mockPrimary.AssertExpectations(t) } diff --git a/light/helpers_test.go b/light/helpers_test.go index 2ca951913..1d25f9166 100644 --- a/light/helpers_test.go +++ b/light/helpers_test.go @@ -3,10 +3,12 @@ package light_test import ( "time" + "github.com/stretchr/testify/mock" "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" "github.com/tendermint/tendermint/crypto/tmhash" tmtime "github.com/tendermint/tendermint/libs/time" + provider_mocks "github.com/tendermint/tendermint/light/provider/mocks" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/tendermint/tendermint/types" "github.com/tendermint/tendermint/version" @@ -169,12 +171,12 @@ func (pkz privKeys) ChangeKeys(delta int) privKeys { return newKeys.Extend(delta) } -// Generates the header and validator set to create a full entire mock node with blocks to height ( -// blockSize) and with variation in validator sets. BlockIntervals are in per minute. +// genLightBlocksWithKeys generates the header and validator set to create +// blocks to height. BlockIntervals are in per minute. // NOTE: Expected to have a large validator set size ~ 100 validators. -func genMockNodeWithKeys( +func genLightBlocksWithKeys( chainID string, - blockSize int64, + numBlocks int64, valSize int, valVariation float32, bTime time.Time) ( @@ -183,9 +185,9 @@ func genMockNodeWithKeys( map[int64]privKeys) { var ( - headers = make(map[int64]*types.SignedHeader, blockSize) - valset = make(map[int64]*types.ValidatorSet, blockSize+1) - keymap = make(map[int64]privKeys, blockSize+1) + headers = make(map[int64]*types.SignedHeader, numBlocks) + valset = make(map[int64]*types.ValidatorSet, numBlocks+1) + keymap = make(map[int64]privKeys, numBlocks+1) keys = genPrivKeys(valSize) totalVariation = valVariation valVariationInt int @@ -207,7 +209,7 @@ func genMockNodeWithKeys( valset[1] = keys.ToValidators(2, 0) keys = newKeys - for height := int64(2); height <= blockSize; height++ { + for height := int64(2); height <= numBlocks; height++ { totalVariation += valVariation valVariationInt = int(totalVariation) totalVariation = -float32(valVariationInt) @@ -226,17 +228,14 @@ func genMockNodeWithKeys( return headers, valset, keymap } -func genMockNode( - chainID string, - blockSize int64, - valSize int, - valVariation float32, - bTime time.Time) ( - string, - map[int64]*types.SignedHeader, - map[int64]*types.ValidatorSet) { - headers, valset, _ := genMockNodeWithKeys(chainID, blockSize, valSize, valVariation, bTime) - return chainID, headers, valset +func mockNodeFromHeadersAndVals(headers map[int64]*types.SignedHeader, + vals map[int64]*types.ValidatorSet) *provider_mocks.Provider { + mockNode := &provider_mocks.Provider{} + for i, header := range headers { + lb := &types.LightBlock{SignedHeader: header, ValidatorSet: vals[i]} + mockNode.On("LightBlock", mock.Anything, i).Return(lb, nil) + } + return mockNode } func hash(s string) []byte { diff --git a/light/provider/mock/deadmock.go b/light/provider/mock/deadmock.go deleted file mode 100644 index 6045e45f6..000000000 --- a/light/provider/mock/deadmock.go +++ /dev/null @@ -1,30 +0,0 @@ -package mock - -import ( - "context" - "fmt" - - "github.com/tendermint/tendermint/light/provider" - "github.com/tendermint/tendermint/types" -) - -type deadMock struct { - id string -} - -// NewDeadMock creates a mock provider that always errors. id is used in case of multiple providers. -func NewDeadMock(id string) provider.Provider { - return &deadMock{id: id} -} - -func (p *deadMock) String() string { - return fmt.Sprintf("DeadMock-%s", p.id) -} - -func (p *deadMock) LightBlock(_ context.Context, height int64) (*types.LightBlock, error) { - return nil, provider.ErrNoResponse -} - -func (p *deadMock) ReportEvidence(_ context.Context, ev types.Evidence) error { - return provider.ErrNoResponse -} diff --git a/light/provider/mock/mock.go b/light/provider/mock/mock.go deleted file mode 100644 index fcb8a6fa4..000000000 --- a/light/provider/mock/mock.go +++ /dev/null @@ -1,125 +0,0 @@ -package mock - -import ( - "context" - "errors" - "fmt" - "strings" - "sync" - "time" - - "github.com/tendermint/tendermint/light/provider" - "github.com/tendermint/tendermint/types" -) - -type Mock struct { - id string - - mtx sync.Mutex - headers map[int64]*types.SignedHeader - vals map[int64]*types.ValidatorSet - evidenceToReport map[string]types.Evidence // hash => evidence - latestHeight int64 -} - -var _ provider.Provider = (*Mock)(nil) - -// New creates a mock provider with the given set of headers and validator -// sets. -func New(id string, headers map[int64]*types.SignedHeader, vals map[int64]*types.ValidatorSet) *Mock { - height := int64(0) - for h := range headers { - if h > height { - height = h - } - } - return &Mock{ - id: id, - headers: headers, - vals: vals, - evidenceToReport: make(map[string]types.Evidence), - latestHeight: height, - } -} - -func (p *Mock) String() string { - var headers strings.Builder - for _, h := range p.headers { - fmt.Fprintf(&headers, " %d:%X", h.Height, h.Hash()) - } - - var vals strings.Builder - for _, v := range p.vals { - fmt.Fprintf(&vals, " %X", v.Hash()) - } - - return fmt.Sprintf("Mock{id: %s, headers: %s, vals: %v}", p.id, headers.String(), vals.String()) -} - -func (p *Mock) LightBlock(ctx context.Context, height int64) (*types.LightBlock, error) { - p.mtx.Lock() - defer p.mtx.Unlock() - - select { - case <-ctx.Done(): - return nil, ctx.Err() - case <-time.After(10 * time.Millisecond): - } - - var lb *types.LightBlock - - if height > p.latestHeight { - return nil, provider.ErrHeightTooHigh - } - - if height == 0 && len(p.headers) > 0 { - height = p.latestHeight - } - - if _, ok := p.headers[height]; ok { - sh := p.headers[height] - vals := p.vals[height] - lb = &types.LightBlock{ - SignedHeader: sh, - ValidatorSet: vals, - } - } - if lb == nil { - return nil, provider.ErrLightBlockNotFound - } - if lb.SignedHeader == nil || lb.ValidatorSet == nil { - return nil, provider.ErrBadLightBlock{Reason: errors.New("nil header or vals")} - } - if err := lb.ValidateBasic(lb.ChainID); err != nil { - return nil, provider.ErrBadLightBlock{Reason: err} - } - return lb, nil -} - -func (p *Mock) ReportEvidence(_ context.Context, ev types.Evidence) error { - p.evidenceToReport[string(ev.Hash())] = ev - return nil -} - -func (p *Mock) HasEvidence(ev types.Evidence) bool { - _, ok := p.evidenceToReport[string(ev.Hash())] - return ok -} - -func (p *Mock) AddLightBlock(lb *types.LightBlock) { - p.mtx.Lock() - defer p.mtx.Unlock() - - if err := lb.ValidateBasic(lb.ChainID); err != nil { - panic(fmt.Sprintf("unable to add light block, err: %v", err)) - } - p.headers[lb.Height] = lb.SignedHeader - p.vals[lb.Height] = lb.ValidatorSet - if lb.Height > p.latestHeight { - p.latestHeight = lb.Height - } -} - -func (p *Mock) Copy(id string) *Mock { - return New(id, p.headers, p.vals) -} diff --git a/light/provider/mocks/provider.go b/light/provider/mocks/provider.go new file mode 100644 index 000000000..5a58d6b32 --- /dev/null +++ b/light/provider/mocks/provider.go @@ -0,0 +1,53 @@ +// Code generated by mockery v0.0.0-dev. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + types "github.com/tendermint/tendermint/types" +) + +// Provider is an autogenerated mock type for the Provider type +type Provider struct { + mock.Mock +} + +// LightBlock provides a mock function with given fields: ctx, height +func (_m *Provider) LightBlock(ctx context.Context, height int64) (*types.LightBlock, error) { + ret := _m.Called(ctx, height) + + var r0 *types.LightBlock + if rf, ok := ret.Get(0).(func(context.Context, int64) *types.LightBlock); ok { + r0 = rf(ctx, height) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.LightBlock) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok { + r1 = rf(ctx, height) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ReportEvidence provides a mock function with given fields: _a0, _a1 +func (_m *Provider) ReportEvidence(_a0 context.Context, _a1 types.Evidence) error { + ret := _m.Called(_a0, _a1) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, types.Evidence) error); ok { + r0 = rf(_a0, _a1) + } else { + r0 = ret.Error(0) + } + + return r0 +} From 6a94b55d1293ade5af361535f84bd03b708ddac3 Mon Sep 17 00:00:00 2001 From: Sam Kleinman Date: Wed, 28 Jul 2021 14:20:40 -0400 Subject: [PATCH 14/35] rpc: add documentation for genesis chunked api (#6776) --- CHANGELOG_PENDING.md | 1 + rpc/openapi/openapi.yaml | 65 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 65 insertions(+), 1 deletion(-) diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md index de3a18ab6..9de5b8bcb 100644 --- a/CHANGELOG_PENDING.md +++ b/CHANGELOG_PENDING.md @@ -24,6 +24,7 @@ Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermi - [fastsync/rpc] \#6620 Add TotalSyncedTime & RemainingTime to SyncInfo in /status RPC (@JayT106) - [rpc/grpc] \#6725 Mark gRPC in the RPC layer as deprecated. - [blockchain/v2] \#6730 Fast Sync v2 is deprecated, please use v0 + - [rpc] Add genesis_chunked method to support paginated and parallel fetching of large genesis documents. - Apps - [ABCI] \#6408 Change the `key` and `value` fields from `[]byte` to `string` in the `EventAttribute` type. (@alexanderbez) diff --git a/rpc/openapi/openapi.yaml b/rpc/openapi/openapi.yaml index a2cbd62da..bb35d34ac 100644 --- a/rpc/openapi/openapi.yaml +++ b/rpc/openapi/openapi.yaml @@ -806,6 +806,7 @@ paths: application/json: schema: $ref: "#/components/schemas/ErrorResponse" + /genesis: get: summary: Get Genesis @@ -813,7 +814,7 @@ paths: tags: - Info description: | - Get genesis. + Get the genesis document. responses: "200": description: Genesis results. @@ -827,6 +828,39 @@ paths: application/json: schema: $ref: "#/components/schemas/ErrorResponse" + + /genesis_chunked: + get: + summary: Get Genesis in paginated chunks + operationId: genesis_chunked + tags: + - Info + description: | + Get genesis document in a paginated/chunked format to make it + easier to iterate through larger gensis structures. + parameters: + - in: query + name: chunkID + description: Sequence number of the chunk to download. + schema: + type: integer + default: 0 + example: 1 + responses: + "200": + description: Genesis results. + content: + application/json: + schema: + $ref: "#/components/schemas/GenesisChunkedResponse" + "500": + description: Error + content: + application/json: + schema: + $ref: "#/components/schemas/ErrorResponse" + + /dump_consensus_state: get: summary: Get consensus state @@ -1894,6 +1928,35 @@ components: properties: {} type: object + GenesisChunkedResponse: + type: object + required: + - "jsonrpc" + - "id" + - "result" + properties: + jsonrpc: + type: string + example: "2.0" + id: + type: integer + example: 0 + result: + required: + - "chunk" + - "total" + - "data" + properties: + chunk: + type: integer + example: 0 + total: + type: integer + example: 1 + data: + type: string + example: "Z2VuZXNpcwo=" + DumpConsensusResponse: type: object required: From 8f06e0c9e7b76b7705c40d3a6e489276d65910f3 Mon Sep 17 00:00:00 2001 From: "M. J. Fromberger" Date: Wed, 28 Jul 2021 12:38:46 -0700 Subject: [PATCH 15/35] cleanup: remove redundant error plumbing (#6778) This is a mostly-automated fixup using Comby (https://comby.dev) to remove lexically-obvious redundant error checks. No functional changes are intended. To reproduce the core change: # Collapse redundant error check conditionals % comby -in-place 'if err != nil { return err } return nil' 'return err' .go # Fold out unnecessary error temporaries % comby -in-place ':[spc~^\s*]err :[~:?]= :[any] return err' ':[spc]return :[any]' .go Fixes #6479 and related cases. --- abci/types/messages.go | 6 +----- privval/signer_listener_endpoint.go | 7 +------ state/indexer/sink/psql/psql_test.go | 7 +------ state/store.go | 7 +------ test/e2e/runner/cleanup.go | 20 +++----------------- test/e2e/runner/wait.go | 5 +---- test/fuzz/rpc/jsonrpc/server/handler.go | 3 +-- types/node_key.go | 6 +----- 8 files changed, 10 insertions(+), 51 deletions(-) diff --git a/abci/types/messages.go b/abci/types/messages.go index e0605c4e5..74f3cc75c 100644 --- a/abci/types/messages.go +++ b/abci/types/messages.go @@ -15,11 +15,7 @@ const ( func WriteMessage(msg proto.Message, w io.Writer) error { protoWriter := protoio.NewDelimitedWriter(w) _, err := protoWriter.WriteMsg(msg) - if err != nil { - return err - } - - return nil + return err } // ReadMessage reads a varint length-delimited protobuf message. diff --git a/privval/signer_listener_endpoint.go b/privval/signer_listener_endpoint.go index 16ffc5c98..292e7a476 100644 --- a/privval/signer_listener_endpoint.go +++ b/privval/signer_listener_endpoint.go @@ -142,12 +142,7 @@ func (sl *SignerListenerEndpoint) ensureConnection(maxWait time.Duration) error // block until connected or timeout sl.Logger.Info("SignerListener: Blocking for connection") sl.triggerConnect() - err := sl.WaitConnection(sl.connectionAvailableCh, maxWait) - if err != nil { - return err - } - - return nil + return sl.WaitConnection(sl.connectionAvailableCh, maxWait) } func (sl *SignerListenerEndpoint) acceptNewConnection() (net.Conn, error) { diff --git a/state/indexer/sink/psql/psql_test.go b/state/indexer/sink/psql/psql_test.go index ee1af5a5f..0df773a53 100644 --- a/state/indexer/sink/psql/psql_test.go +++ b/state/indexer/sink/psql/psql_test.go @@ -255,12 +255,7 @@ func verifyTimeStamp(tb string) error { if rows.Next() { var ts string - err = rows.Scan(&ts) - if err != nil { - return err - } - - return nil + return rows.Scan(&ts) } return errors.New("no result") diff --git a/state/store.go b/state/store.go index 84b19a685..0ecd888ca 100644 --- a/state/store.go +++ b/state/store.go @@ -661,10 +661,5 @@ func (store dbStore) saveConsensusParamsInfo( return err } - err = batch.Set(consensusParamsKey(nextHeight), bz) - if err != nil { - return err - } - - return nil + return batch.Set(consensusParamsKey(nextHeight), bz) } diff --git a/test/e2e/runner/cleanup.go b/test/e2e/runner/cleanup.go index d99ca54cf..d17c75075 100644 --- a/test/e2e/runner/cleanup.go +++ b/test/e2e/runner/cleanup.go @@ -15,11 +15,7 @@ func Cleanup(testnet *e2e.Testnet) error { if err != nil { return err } - err = cleanupDir(testnet.Dir) - if err != nil { - return err - } - return nil + return cleanupDir(testnet.Dir) } // cleanupDocker removes all E2E resources (with label e2e=True), regardless @@ -37,13 +33,8 @@ func cleanupDocker() error { return err } - err = exec("bash", "-c", fmt.Sprintf( + return exec("bash", "-c", fmt.Sprintf( "docker network ls -q --filter label=e2e | xargs %v docker network rm", xargsR)) - if err != nil { - return err - } - - return nil } // cleanupDir cleans up a testnet directory @@ -74,10 +65,5 @@ func cleanupDir(dir string) error { return err } - err = os.RemoveAll(dir) - if err != nil { - return err - } - - return nil + return os.RemoveAll(dir) } diff --git a/test/e2e/runner/wait.go b/test/e2e/runner/wait.go index 4c16fb808..9f3a4c438 100644 --- a/test/e2e/runner/wait.go +++ b/test/e2e/runner/wait.go @@ -21,10 +21,7 @@ func Wait(testnet *e2e.Testnet, blocks int64) error { func WaitUntil(testnet *e2e.Testnet, height int64) error { logger.Info(fmt.Sprintf("Waiting for all nodes to reach height %v...", height)) _, err := waitForAllNodes(testnet, height, waitingTime(len(testnet.Nodes))) - if err != nil { - return err - } - return nil + return err } // waitingTime estimates how long it should take for a node to reach the height. diff --git a/test/fuzz/rpc/jsonrpc/server/handler.go b/test/fuzz/rpc/jsonrpc/server/handler.go index eed18ceff..08f7e2b6b 100644 --- a/test/fuzz/rpc/jsonrpc/server/handler.go +++ b/test/fuzz/rpc/jsonrpc/server/handler.go @@ -59,6 +59,5 @@ func Fuzz(data []byte) int { func outputJSONIsSlice(input []byte) bool { slice := []interface{}{} - err := json.Unmarshal(input, &slice) - return err == nil + return json.Unmarshal(input, &slice) == nil } diff --git a/types/node_key.go b/types/node_key.go index b8277649a..547fa1696 100644 --- a/types/node_key.go +++ b/types/node_key.go @@ -33,11 +33,7 @@ func (nodeKey NodeKey) SaveAs(filePath string) error { if err != nil { return err } - err = ioutil.WriteFile(filePath, jsonBytes, 0600) - if err != nil { - return err - } - return nil + return ioutil.WriteFile(filePath, jsonBytes, 0600) } // LoadOrGenNodeKey attempts to load the NodeKey from the given filePath. If From 9a2a7d43073d678c4dc24747666e0508f3003bc7 Mon Sep 17 00:00:00 2001 From: JayT106 Date: Thu, 29 Jul 2021 06:52:53 -0400 Subject: [PATCH 16/35] state/privval: vote timestamp fix (#6748) --- internal/consensus/common_test.go | 29 ++++++++++++++++++++++++++++- internal/consensus/state.go | 1 + internal/consensus/state_test.go | 24 ++++++++++++++++++++++++ 3 files changed, 53 insertions(+), 1 deletion(-) diff --git a/internal/consensus/common_test.go b/internal/consensus/common_test.go index 26170f3bc..17ba1ce2e 100644 --- a/internal/consensus/common_test.go +++ b/internal/consensus/common_test.go @@ -88,6 +88,7 @@ type validatorStub struct { Round int32 types.PrivValidator VotingPower int64 + lastVote *types.Vote } const testMinPower int64 = 10 @@ -121,8 +122,18 @@ func (vs *validatorStub) signVote( BlockID: types.BlockID{Hash: hash, PartSetHeader: header}, } v := vote.ToProto() - err = vs.PrivValidator.SignVote(context.Background(), config.ChainID(), v) + if err := vs.PrivValidator.SignVote(context.Background(), config.ChainID(), v); err != nil { + return nil, fmt.Errorf("sign vote failed: %w", err) + } + + // ref: signVote in FilePV, the vote should use the privious vote info when the sign data is the same. + if signDataIsEqual(vs.lastVote, v) { + v.Signature = vs.lastVote.Signature + v.Timestamp = vs.lastVote.Timestamp + } + vote.Signature = v.Signature + vote.Timestamp = v.Timestamp return vote, err } @@ -139,6 +150,9 @@ func signVote( if err != nil { panic(fmt.Errorf("failed to sign vote: %v", err)) } + + vs.lastVote = v + return v } @@ -876,3 +890,16 @@ func newKVStore() abci.Application { func newPersistentKVStoreWithPath(dbDir string) abci.Application { return kvstore.NewPersistentKVStoreApplication(dbDir) } + +func signDataIsEqual(v1 *types.Vote, v2 *tmproto.Vote) bool { + if v1 == nil || v2 == nil { + return false + } + + return v1.Type == v2.Type && + bytes.Equal(v1.BlockID.Hash, v2.BlockID.GetHash()) && + v1.Height == v2.GetHeight() && + v1.Round == v2.Round && + bytes.Equal(v1.ValidatorAddress.Bytes(), v2.GetValidatorAddress()) && + v1.ValidatorIndex == v2.GetValidatorIndex() +} diff --git a/internal/consensus/state.go b/internal/consensus/state.go index a20f488e4..f7e44c600 100644 --- a/internal/consensus/state.go +++ b/internal/consensus/state.go @@ -2218,6 +2218,7 @@ func (cs *State) signVote( err := cs.privValidator.SignVote(ctx, cs.state.ChainID, v) vote.Signature = v.Signature + vote.Timestamp = v.Timestamp return vote, err } diff --git a/internal/consensus/state_test.go b/internal/consensus/state_test.go index b088e2ac7..b3b7c81a3 100644 --- a/internal/consensus/state_test.go +++ b/internal/consensus/state_test.go @@ -1939,6 +1939,30 @@ func TestStateOutputVoteStats(t *testing.T) { } +func TestSignSameVoteTwice(t *testing.T) { + config := configSetup(t) + + _, vss := randState(config, 2) + + randBytes := tmrand.Bytes(tmhash.Size) + + vote := signVote(vss[1], + config, + tmproto.PrecommitType, + randBytes, + types.PartSetHeader{Total: 10, Hash: randBytes}, + ) + + vote2 := signVote(vss[1], + config, + tmproto.PrecommitType, + randBytes, + types.PartSetHeader{Total: 10, Hash: randBytes}, + ) + + require.Equal(t, vote, vote2) +} + // subscribe subscribes test client to the given query and returns a channel with cap = 1. func subscribe(eventBus *types.EventBus, q tmpubsub.Query) <-chan tmpubsub.Message { sub, err := eventBus.Subscribe(context.Background(), testSubscriber, q) From 6dd8984fef8742ec6e5481040c159941c9d0a819 Mon Sep 17 00:00:00 2001 From: "M. J. Fromberger" Date: Thu, 29 Jul 2021 19:28:32 -0700 Subject: [PATCH 17/35] Fix and clarify breaks from select cases. (#6781) Update those break statements inside case clauses that are intended to reach an enclosing for loop, so that they correctly exit the loop. The candidate files for this change were located using: % staticcheck -checks SA4011 ./... | cut -d: -f-2 This change is intended to preserve the intended semantics of the code, but since the code as-written did not have its intended effect, some behaviour may change. Specifically: Some loops may have run longer than they were supposed to, prior to this change. In one case I was not able to clearly determine the intended outcome. That case has been commented but otherwise left as-written. Fixes #6780. --- crypto/merkle/proof.go | 5 ++++- internal/p2p/peermanager.go | 2 +- state/indexer/block/kv/kv.go | 15 +++++++++------ state/indexer/tx/kv/kv.go | 18 +++++++++++------- 4 files changed, 25 insertions(+), 15 deletions(-) diff --git a/crypto/merkle/proof.go b/crypto/merkle/proof.go index 2994e8048..80b289d23 100644 --- a/crypto/merkle/proof.go +++ b/crypto/merkle/proof.go @@ -204,7 +204,10 @@ func (spn *ProofNode) FlattenAunts() [][]byte { case spn.Right != nil: innerHashes = append(innerHashes, spn.Right.Hash) default: - break + // FIXME(fromberger): Per the documentation above, exactly one of + // these fields should be set. If that is true, this should probably + // be a panic since it violates the invariant. If not, when can it + // be OK to have no siblings? Does this occur at the leaves? } spn = spn.Parent } diff --git a/internal/p2p/peermanager.go b/internal/p2p/peermanager.go index fd6f96933..1e9afb38b 100644 --- a/internal/p2p/peermanager.go +++ b/internal/p2p/peermanager.go @@ -385,7 +385,7 @@ func (m *PeerManager) prunePeers() error { peerID := ranked[i].ID switch { case m.store.Size() <= int(m.options.MaxPeers): - break + return nil case m.dialing[peerID]: case m.connected[peerID]: default: diff --git a/state/indexer/block/kv/kv.go b/state/indexer/block/kv/kv.go index 1787be9ef..bc90eadf5 100644 --- a/state/indexer/block/kv/kv.go +++ b/state/indexer/block/kv/kv.go @@ -186,6 +186,7 @@ func (idx *BlockerIndexer) Search(ctx context.Context, q *query.Query) ([]int64, // fetch matching heights results = make([]int64, 0, len(filteredHeights)) +heights: for _, hBz := range filteredHeights { h := int64FromBytes(hBz) @@ -199,7 +200,7 @@ func (idx *BlockerIndexer) Search(ctx context.Context, q *query.Query) ([]int64, select { case <-ctx.Done(): - break + break heights default: } @@ -240,7 +241,7 @@ func (idx *BlockerIndexer) matchRange( } defer it.Close() -LOOP: +iter: for ; it.Valid(); it.Next() { var ( eventValue string @@ -260,7 +261,7 @@ LOOP: if _, ok := qr.AnyBound().(int64); ok { v, err := strconv.ParseInt(eventValue, 10, 64) if err != nil { - continue LOOP + continue iter } include := true @@ -279,7 +280,7 @@ LOOP: select { case <-ctx.Done(): - break + break iter default: } @@ -372,12 +373,13 @@ func (idx *BlockerIndexer) match( } defer it.Close() + iterExists: for ; it.Valid(); it.Next() { tmpHeights[string(it.Value())] = it.Value() select { case <-ctx.Done(): - break + break iterExists default: } @@ -399,6 +401,7 @@ func (idx *BlockerIndexer) match( } defer it.Close() + iterContains: for ; it.Valid(); it.Next() { eventValue, err := parseValueFromEventKey(it.Key()) if err != nil { @@ -411,7 +414,7 @@ func (idx *BlockerIndexer) match( select { case <-ctx.Done(): - break + break iterContains default: } diff --git a/state/indexer/tx/kv/kv.go b/state/indexer/tx/kv/kv.go index 5d310eea7..080dbce2c 100644 --- a/state/indexer/tx/kv/kv.go +++ b/state/indexer/tx/kv/kv.go @@ -219,6 +219,7 @@ func (txi *TxIndex) Search(ctx context.Context, q *query.Query) ([]*abci.TxResul } results := make([]*abci.TxResult, 0, len(filteredHashes)) +hashes: for _, h := range filteredHashes { res, err := txi.Get(h) if err != nil { @@ -229,7 +230,7 @@ func (txi *TxIndex) Search(ctx context.Context, q *query.Query) ([]*abci.TxResul // Potentially exit early. select { case <-ctx.Done(): - break + break hashes default: } } @@ -285,13 +286,14 @@ func (txi *TxIndex) match( } defer it.Close() + iterEqual: for ; it.Valid(); it.Next() { tmpHashes[string(it.Value())] = it.Value() // Potentially exit early. select { case <-ctx.Done(): - break + break iterEqual default: } } @@ -308,13 +310,14 @@ func (txi *TxIndex) match( } defer it.Close() + iterExists: for ; it.Valid(); it.Next() { tmpHashes[string(it.Value())] = it.Value() // Potentially exit early. select { case <-ctx.Done(): - break + break iterExists default: } } @@ -332,6 +335,7 @@ func (txi *TxIndex) match( } defer it.Close() + iterContains: for ; it.Valid(); it.Next() { value, err := parseValueFromKey(it.Key()) if err != nil { @@ -344,7 +348,7 @@ func (txi *TxIndex) match( // Potentially exit early. select { case <-ctx.Done(): - break + break iterContains default: } } @@ -412,7 +416,7 @@ func (txi *TxIndex) matchRange( } defer it.Close() -LOOP: +iter: for ; it.Valid(); it.Next() { value, err := parseValueFromKey(it.Key()) if err != nil { @@ -421,7 +425,7 @@ LOOP: if _, ok := qr.AnyBound().(int64); ok { v, err := strconv.ParseInt(value, 10, 64) if err != nil { - continue LOOP + continue iter } include := true @@ -448,7 +452,7 @@ LOOP: // Potentially exit early. select { case <-ctx.Done(): - break + break iter default: } } From 3aec71cdd4fdeab122f1ad8ca18ec076034814c1 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 30 Jul 2021 09:21:27 -0400 Subject: [PATCH 18/35] build(deps): Bump styfle/cancel-workflow-action from 0.9.0 to 0.9.1 (#6786) --- .github/workflows/janitor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/janitor.yml b/.github/workflows/janitor.yml index ccacb6eeb..e6bc45ec1 100644 --- a/.github/workflows/janitor.yml +++ b/.github/workflows/janitor.yml @@ -10,7 +10,7 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 3 steps: - - uses: styfle/cancel-workflow-action@0.9.0 + - uses: styfle/cancel-workflow-action@0.9.1 with: workflow_id: 1041851,1401230,2837803 access_token: ${{ github.token }} From 02f8e4c0bd1d94c4687e32f1fc99537f9e58da7f Mon Sep 17 00:00:00 2001 From: Callum Waters Date: Fri, 30 Jul 2021 17:37:04 +0200 Subject: [PATCH 19/35] blockstore: fix problem with seen commit (#6782) --- abci/client/mocks/client.go | 2 +- internal/consensus/mocks/cons_sync_reactor.go | 2 +- internal/consensus/replay_test.go | 4 +- internal/consensus/state.go | 23 ++- internal/evidence/mocks/block_store.go | 2 +- internal/p2p/mocks/connection.go | 2 +- internal/p2p/mocks/peer.go | 2 +- internal/p2p/mocks/transport.go | 2 +- internal/statesync/mocks/state_provider.go | 2 +- light/provider/mocks/provider.go | 2 +- light/rpc/mocks/light_client.go | 2 +- proxy/mocks/app_conn_consensus.go | 2 +- proxy/mocks/app_conn_mempool.go | 2 +- proxy/mocks/app_conn_query.go | 2 +- proxy/mocks/app_conn_snapshot.go | 2 +- rpc/client/evidence_test.go | 27 ++- rpc/client/mocks/client.go | 2 +- rpc/core/blocks.go | 11 +- rpc/core/blocks_test.go | 2 +- state/indexer/mocks/event_sink.go | 167 ++++++++++++++++++ state/mocks/block_store.go | 14 +- state/mocks/evidence_pool.go | 2 +- state/mocks/store.go | 2 +- state/services.go | 2 +- store/store.go | 29 ++- store/store_test.go | 20 +-- 26 files changed, 258 insertions(+), 73 deletions(-) create mode 100644 state/indexer/mocks/event_sink.go diff --git a/abci/client/mocks/client.go b/abci/client/mocks/client.go index 55542753e..621ac1af7 100644 --- a/abci/client/mocks/client.go +++ b/abci/client/mocks/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/internal/consensus/mocks/cons_sync_reactor.go b/internal/consensus/mocks/cons_sync_reactor.go index f21094dbb..db6afe8df 100644 --- a/internal/consensus/mocks/cons_sync_reactor.go +++ b/internal/consensus/mocks/cons_sync_reactor.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.7.5. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/internal/consensus/replay_test.go b/internal/consensus/replay_test.go index e7c480cea..4d1c9c6b2 100644 --- a/internal/consensus/replay_test.go +++ b/internal/consensus/replay_test.go @@ -1203,8 +1203,8 @@ func (bs *mockBlockStore) SaveBlock(block *types.Block, blockParts *types.PartSe func (bs *mockBlockStore) LoadBlockCommit(height int64) *types.Commit { return bs.commits[height-1] } -func (bs *mockBlockStore) LoadSeenCommit(height int64) *types.Commit { - return bs.commits[height-1] +func (bs *mockBlockStore) LoadSeenCommit() *types.Commit { + return bs.commits[len(bs.commits)-1] } func (bs *mockBlockStore) PruneBlocks(height int64) (uint64, error) { diff --git a/internal/consensus/state.go b/internal/consensus/state.go index f7e44c600..4da989b40 100644 --- a/internal/consensus/state.go +++ b/internal/consensus/state.go @@ -314,7 +314,14 @@ func (cs *State) LoadCommit(height int64) *types.Commit { defer cs.mtx.RUnlock() if height == cs.blockStore.Height() { - return cs.blockStore.LoadSeenCommit(height) + commit := cs.blockStore.LoadSeenCommit() + // NOTE: Retrieving the height of the most recent block and retrieving + // the most recent commit does not currently occur as an atomic + // operation. We check the height and commit here in case a more recent + // commit has arrived since retrieving the latest height. + if commit != nil && commit.Height == height { + return commit + } } return cs.blockStore.LoadBlockCommit(height) @@ -594,15 +601,19 @@ func (cs *State) sendInternalMessage(mi msgInfo) { // Reconstruct LastCommit from SeenCommit, which we saved along with the block, // (which happens even before saving the state) func (cs *State) reconstructLastCommit(state sm.State) { - seenCommit := cs.blockStore.LoadSeenCommit(state.LastBlockHeight) - if seenCommit == nil { + commit := cs.blockStore.LoadSeenCommit() + if commit == nil || commit.Height != state.LastBlockHeight { + commit = cs.blockStore.LoadBlockCommit(state.LastBlockHeight) + } + + if commit == nil { panic(fmt.Sprintf( - "failed to reconstruct last commit; seen commit for height %v not found", + "failed to reconstruct last commit; commit for height %v not found", state.LastBlockHeight, )) } - lastPrecommits := types.CommitToVoteSet(state.ChainID, seenCommit, state.LastValidators) + lastPrecommits := types.CommitToVoteSet(state.ChainID, commit, state.LastValidators) if !lastPrecommits.HasTwoThirdsMajority() { panic("failed to reconstruct last commit; does not have +2/3 maj") } @@ -2318,7 +2329,7 @@ func (cs *State) checkDoubleSigningRisk(height int64) error { } for i := int64(1); i < doubleSignCheckHeight; i++ { - lastCommit := cs.blockStore.LoadSeenCommit(height - i) + lastCommit := cs.LoadCommit(height - i) if lastCommit != nil { for sigIdx, s := range lastCommit.Signatures { if s.BlockIDFlag == types.BlockIDFlagCommit && bytes.Equal(s.ValidatorAddress, valAddr) { diff --git a/internal/evidence/mocks/block_store.go b/internal/evidence/mocks/block_store.go index e6205939a..7cda611d1 100644 --- a/internal/evidence/mocks/block_store.go +++ b/internal/evidence/mocks/block_store.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/internal/p2p/mocks/connection.go b/internal/p2p/mocks/connection.go index a0d75502b..27b9c24f9 100644 --- a/internal/p2p/mocks/connection.go +++ b/internal/p2p/mocks/connection.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/internal/p2p/mocks/peer.go b/internal/p2p/mocks/peer.go index 436542915..80f8e2bf8 100644 --- a/internal/p2p/mocks/peer.go +++ b/internal/p2p/mocks/peer.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/internal/p2p/mocks/transport.go b/internal/p2p/mocks/transport.go index d45cab016..a96204c0c 100644 --- a/internal/p2p/mocks/transport.go +++ b/internal/p2p/mocks/transport.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/internal/statesync/mocks/state_provider.go b/internal/statesync/mocks/state_provider.go index 4f367380d..1e1ec240e 100644 --- a/internal/statesync/mocks/state_provider.go +++ b/internal/statesync/mocks/state_provider.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/light/provider/mocks/provider.go b/light/provider/mocks/provider.go index 5a58d6b32..aca853667 100644 --- a/light/provider/mocks/provider.go +++ b/light/provider/mocks/provider.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/light/rpc/mocks/light_client.go b/light/rpc/mocks/light_client.go index 7bd0175c5..f4387a9c7 100644 --- a/light/rpc/mocks/light_client.go +++ b/light/rpc/mocks/light_client.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/proxy/mocks/app_conn_consensus.go b/proxy/mocks/app_conn_consensus.go index 3bf787dbc..55157e713 100644 --- a/proxy/mocks/app_conn_consensus.go +++ b/proxy/mocks/app_conn_consensus.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/proxy/mocks/app_conn_mempool.go b/proxy/mocks/app_conn_mempool.go index 02b8bea8c..445163cfd 100644 --- a/proxy/mocks/app_conn_mempool.go +++ b/proxy/mocks/app_conn_mempool.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/proxy/mocks/app_conn_query.go b/proxy/mocks/app_conn_query.go index 6af88ad7c..207dd5fcf 100644 --- a/proxy/mocks/app_conn_query.go +++ b/proxy/mocks/app_conn_query.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/proxy/mocks/app_conn_snapshot.go b/proxy/mocks/app_conn_snapshot.go index 6964a8425..a5413cc6e 100644 --- a/proxy/mocks/app_conn_snapshot.go +++ b/proxy/mocks/app_conn_snapshot.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/rpc/client/evidence_test.go b/rpc/client/evidence_test.go index 944766152..0ff158e56 100644 --- a/rpc/client/evidence_test.go +++ b/rpc/client/evidence_test.go @@ -116,12 +116,6 @@ func TestBroadcastEvidence_DuplicateVoteEvidence(t *testing.T) { defer cancel() n, config := NodeSuite(t) - - // previous versions of this test used a shared fixture with - // other tests, and in this version we give it a little time - // for the node to make progress before running the test - time.Sleep(100 * time.Millisecond) - chainID := config.ChainID() pv, err := privval.LoadOrGenFilePV(config.PrivValidator.KeyFile(), config.PrivValidator.StateFile()) @@ -131,6 +125,9 @@ func TestBroadcastEvidence_DuplicateVoteEvidence(t *testing.T) { correct, fakes := makeEvidences(t, pv, chainID) t.Logf("client %d", i) + // make sure that the node has produced enough blocks + waitForBlock(ctx, t, c, 2) + result, err := c.BroadcastEvidence(ctx, correct) require.NoError(t, err, "BroadcastEvidence(%s) failed", correct) assert.Equal(t, correct.Hash(), result.Hash, "expected result hash to match evidence hash") @@ -171,3 +168,21 @@ func TestBroadcastEmptyEvidence(t *testing.T) { assert.Error(t, err) } } + +func waitForBlock(ctx context.Context, t *testing.T, c client.Client, height int64) { + timer := time.NewTimer(0 * time.Millisecond) + defer timer.Stop() + for { + select { + case <-ctx.Done(): + return + case <-timer.C: + status, err := c.Status(ctx) + require.NoError(t, err) + if status.SyncInfo.LatestBlockHeight >= height { + return + } + timer.Reset(200 * time.Millisecond) + } + } +} diff --git a/rpc/client/mocks/client.go b/rpc/client/mocks/client.go index adf1934cd..1da390f4b 100644 --- a/rpc/client/mocks/client.go +++ b/rpc/client/mocks/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/rpc/core/blocks.go b/rpc/core/blocks.go index d57f76a99..081276d0f 100644 --- a/rpc/core/blocks.go +++ b/rpc/core/blocks.go @@ -135,12 +135,19 @@ func (env *Environment) Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes // If the next block has not been committed yet, // use a non-canonical commit if height == env.BlockStore.Height() { - commit := env.BlockStore.LoadSeenCommit(height) - return ctypes.NewResultCommit(&header, commit, false), nil + commit := env.BlockStore.LoadSeenCommit() + // NOTE: we can't yet ensure atomicity of operations in asserting + // whether this is the latest height and retrieving the seen commit + if commit != nil && commit.Height == height { + return ctypes.NewResultCommit(&header, commit, false), nil + } } // Return the canonical commit (comes from the block at height+1) commit := env.BlockStore.LoadBlockCommit(height) + if commit == nil { + return nil, nil + } return ctypes.NewResultCommit(&header, commit, true), nil } diff --git a/rpc/core/blocks_test.go b/rpc/core/blocks_test.go index 70bd4c723..29db2f094 100644 --- a/rpc/core/blocks_test.go +++ b/rpc/core/blocks_test.go @@ -129,7 +129,7 @@ func (mockBlockStore) LoadBlock(height int64) *types.Block { retur func (mockBlockStore) LoadBlockByHash(hash []byte) *types.Block { return nil } func (mockBlockStore) LoadBlockPart(height int64, index int) *types.Part { return nil } func (mockBlockStore) LoadBlockCommit(height int64) *types.Commit { return nil } -func (mockBlockStore) LoadSeenCommit(height int64) *types.Commit { return nil } +func (mockBlockStore) LoadSeenCommit() *types.Commit { return nil } func (mockBlockStore) PruneBlocks(height int64) (uint64, error) { return 0, nil } func (mockBlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) { } diff --git a/state/indexer/mocks/event_sink.go b/state/indexer/mocks/event_sink.go new file mode 100644 index 000000000..515bb4a0b --- /dev/null +++ b/state/indexer/mocks/event_sink.go @@ -0,0 +1,167 @@ +// Code generated by mockery 2.9.0. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + indexer "github.com/tendermint/tendermint/state/indexer" + + query "github.com/tendermint/tendermint/libs/pubsub/query" + + tenderminttypes "github.com/tendermint/tendermint/types" + + types "github.com/tendermint/tendermint/abci/types" +) + +// EventSink is an autogenerated mock type for the EventSink type +type EventSink struct { + mock.Mock +} + +// GetTxByHash provides a mock function with given fields: _a0 +func (_m *EventSink) GetTxByHash(_a0 []byte) (*types.TxResult, error) { + ret := _m.Called(_a0) + + var r0 *types.TxResult + if rf, ok := ret.Get(0).(func([]byte) *types.TxResult); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.TxResult) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func([]byte) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// HasBlock provides a mock function with given fields: _a0 +func (_m *EventSink) HasBlock(_a0 int64) (bool, error) { + ret := _m.Called(_a0) + + var r0 bool + if rf, ok := ret.Get(0).(func(int64) bool); ok { + r0 = rf(_a0) + } else { + r0 = ret.Get(0).(bool) + } + + var r1 error + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IndexBlockEvents provides a mock function with given fields: _a0 +func (_m *EventSink) IndexBlockEvents(_a0 tenderminttypes.EventDataNewBlockHeader) error { + ret := _m.Called(_a0) + + var r0 error + if rf, ok := ret.Get(0).(func(tenderminttypes.EventDataNewBlockHeader) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// IndexTxEvents provides a mock function with given fields: _a0 +func (_m *EventSink) IndexTxEvents(_a0 []*types.TxResult) error { + ret := _m.Called(_a0) + + var r0 error + if rf, ok := ret.Get(0).(func([]*types.TxResult) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SearchBlockEvents provides a mock function with given fields: _a0, _a1 +func (_m *EventSink) SearchBlockEvents(_a0 context.Context, _a1 *query.Query) ([]int64, error) { + ret := _m.Called(_a0, _a1) + + var r0 []int64 + if rf, ok := ret.Get(0).(func(context.Context, *query.Query) []int64); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]int64) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *query.Query) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SearchTxEvents provides a mock function with given fields: _a0, _a1 +func (_m *EventSink) SearchTxEvents(_a0 context.Context, _a1 *query.Query) ([]*types.TxResult, error) { + ret := _m.Called(_a0, _a1) + + var r0 []*types.TxResult + if rf, ok := ret.Get(0).(func(context.Context, *query.Query) []*types.TxResult); ok { + r0 = rf(_a0, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*types.TxResult) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *query.Query) error); ok { + r1 = rf(_a0, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Stop provides a mock function with given fields: +func (_m *EventSink) Stop() error { + ret := _m.Called() + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Type provides a mock function with given fields: +func (_m *EventSink) Type() indexer.EventSinkType { + ret := _m.Called() + + var r0 indexer.EventSinkType + if rf, ok := ret.Get(0).(func() indexer.EventSinkType); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(indexer.EventSinkType) + } + + return r0 +} diff --git a/state/mocks/block_store.go b/state/mocks/block_store.go index 99cadd081..47d7e26a8 100644 --- a/state/mocks/block_store.go +++ b/state/mocks/block_store.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.7.5. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks @@ -137,13 +137,13 @@ func (_m *BlockStore) LoadBlockPart(height int64, index int) *types.Part { return r0 } -// LoadSeenCommit provides a mock function with given fields: height -func (_m *BlockStore) LoadSeenCommit(height int64) *types.Commit { - ret := _m.Called(height) +// LoadSeenCommit provides a mock function with given fields: +func (_m *BlockStore) LoadSeenCommit() *types.Commit { + ret := _m.Called() var r0 *types.Commit - if rf, ok := ret.Get(0).(func(int64) *types.Commit); ok { - r0 = rf(height) + if rf, ok := ret.Get(0).(func() *types.Commit); ok { + r0 = rf() } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*types.Commit) @@ -191,4 +191,4 @@ func (_m *BlockStore) Size() int64 { } return r0 -} \ No newline at end of file +} diff --git a/state/mocks/evidence_pool.go b/state/mocks/evidence_pool.go index 9cfc7b40b..9d6091cde 100644 --- a/state/mocks/evidence_pool.go +++ b/state/mocks/evidence_pool.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/state/mocks/store.go b/state/mocks/store.go index 9a693cc98..a901a2ed1 100644 --- a/state/mocks/store.go +++ b/state/mocks/store.go @@ -1,4 +1,4 @@ -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks diff --git a/state/services.go b/state/services.go index 0ab6b78d0..debd9827b 100644 --- a/state/services.go +++ b/state/services.go @@ -32,7 +32,7 @@ type BlockStore interface { LoadBlockPart(height int64, index int) *types.Part LoadBlockCommit(height int64) *types.Commit - LoadSeenCommit(height int64) *types.Commit + LoadSeenCommit() *types.Commit } //----------------------------------------------------------------------------- diff --git a/store/store.go b/store/store.go index 1396ca777..8848b76d9 100644 --- a/store/store.go +++ b/store/store.go @@ -258,12 +258,13 @@ func (bs *BlockStore) LoadBlockCommit(height int64) *types.Commit { return commit } -// LoadSeenCommit returns the locally seen Commit for the given height. -// This is useful when we've seen a commit, but there has not yet been -// a new block at `height + 1` that includes this commit in its block.LastCommit. -func (bs *BlockStore) LoadSeenCommit(height int64) *types.Commit { +// LoadSeenCommit returns the last locally seen Commit before being +// cannonicalized. This is useful when we've seen a commit, but there +// has not yet been a new block at `height + 1` that includes this +// commit in its block.LastCommit. +func (bs *BlockStore) LoadSeenCommit() *types.Commit { var pbc = new(tmproto.Commit) - bz, err := bs.db.Get(seenCommitKey(height)) + bz, err := bs.db.Get(seenCommitKey()) if err != nil { panic(err) } @@ -329,10 +330,6 @@ func (bs *BlockStore) PruneBlocks(height int64) (uint64, error) { return pruned, err } - if _, err := bs.pruneRange(seenCommitKey(0), seenCommitKey(height), nil); err != nil { - return pruned, err - } - return pruned, nil } @@ -479,13 +476,7 @@ func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, s // Save seen commit (seen +2/3 precommits for block) pbsc := seenCommit.ToProto() seenCommitBytes := mustEncode(pbsc) - if err := batch.Set(seenCommitKey(height), seenCommitBytes); err != nil { - panic(err) - } - - // remove the previous seen commit that we have just replaced with the - // canonical commit - if err := batch.Delete(seenCommitKey(height - 1)); err != nil { + if err := batch.Set(seenCommitKey(), seenCommitBytes); err != nil { panic(err) } @@ -516,7 +507,7 @@ func (bs *BlockStore) SaveSeenCommit(height int64, seenCommit *types.Commit) err if err != nil { return fmt.Errorf("unable to marshal commit: %w", err) } - return bs.db.Set(seenCommitKey(height), seenCommitBytes) + return bs.db.Set(seenCommitKey(), seenCommitBytes) } func (bs *BlockStore) SaveSignedHeader(sh *types.SignedHeader, blockID types.BlockID) error { @@ -612,8 +603,8 @@ func blockCommitKey(height int64) []byte { return key } -func seenCommitKey(height int64) []byte { - key, err := orderedcode.Append(nil, prefixSeenCommit, height) +func seenCommitKey() []byte { + key, err := orderedcode.Append(nil, prefixSeenCommit) if err != nil { panic(err) } diff --git a/store/store_test.go b/store/store_test.go index d07e001e6..2132d9aff 100644 --- a/store/store_test.go +++ b/store/store_test.go @@ -234,14 +234,14 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) { bBlockMeta := bs.LoadBlockMeta(tuple.block.Height) if tuple.eraseSeenCommitInDB { - err := db.Delete(seenCommitKey(tuple.block.Height)) + err := db.Delete(seenCommitKey()) require.NoError(t, err) } if tuple.corruptSeenCommitInDB { - err := db.Set(seenCommitKey(tuple.block.Height), []byte("bogus-seen-commit")) + err := db.Set(seenCommitKey(), []byte("bogus-seen-commit")) require.NoError(t, err) } - bSeenCommit := bs.LoadSeenCommit(tuple.block.Height) + bSeenCommit := bs.LoadSeenCommit() commitHeight := tuple.block.Height - 1 if tuple.eraseCommitInDB { @@ -494,9 +494,8 @@ func TestBlockFetchAtHeight(t *testing.T) { func TestSeenAndCanonicalCommit(t *testing.T) { bs, _ := freshBlockStore() - height := int64(2) loadCommit := func() (interface{}, error) { - meta := bs.LoadSeenCommit(height) + meta := bs.LoadSeenCommit() return meta, nil } @@ -509,20 +508,15 @@ func TestSeenAndCanonicalCommit(t *testing.T) { // produce a few blocks and check that the correct seen and cannoncial commits // are persisted. for h := int64(3); h <= 5; h++ { - c1 := bs.LoadSeenCommit(h) - require.Nil(t, c1) - c2 := bs.LoadBlockCommit(h - 1) - require.Nil(t, c2) blockCommit := makeTestCommit(h-1, tmtime.Now()) block := factory.MakeBlock(state, h, blockCommit) partSet := block.MakePartSet(2) seenCommit := makeTestCommit(h, tmtime.Now()) bs.SaveBlock(block, partSet, seenCommit) - c3 := bs.LoadSeenCommit(h) + c3 := bs.LoadSeenCommit() + require.NotNil(t, c3) + require.Equal(t, h, c3.Height) require.Equal(t, seenCommit.Hash(), c3.Hash()) - // the previous seen commit should be removed - c4 := bs.LoadSeenCommit(h - 1) - require.Nil(t, c4) c5 := bs.LoadBlockCommit(h) require.Nil(t, c5) c6 := bs.LoadBlockCommit(h - 1) From 4e96c6b234bd95477674c0ca7a66379deec6866a Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Fri, 30 Jul 2021 16:47:15 -0400 Subject: [PATCH 20/35] tools: add mockery to tools.go and remove mockery version strings (#6787) This change aims to keep versions of mockery consistent across developer laptops. This change adds mockery to the `tools.go` file so that its version can be managed consistently in the `go.mod` file. Additionally, this change temporarily disables adding mockery's version number to generated files. There is an outstanding issue against the mockery project related to the version string behavior when running from `go get`. I have created a pull request to fix this issue in the mockery project. see: https://github.com/vektra/mockery/issues/397 --- Makefile | 2 +- abci/client/client.go | 2 +- abci/client/mocks/client.go | 2 +- go.mod | 1 + go.sum | 13 +++++++++++++ internal/consensus/mocks/cons_sync_reactor.go | 2 +- internal/consensus/reactor.go | 2 +- internal/evidence/mocks/block_store.go | 2 +- internal/evidence/services.go | 2 +- internal/p2p/mocks/connection.go | 2 +- internal/p2p/mocks/peer.go | 2 +- internal/p2p/mocks/transport.go | 2 +- internal/p2p/peer.go | 2 +- internal/p2p/transport.go | 2 +- internal/statesync/mocks/state_provider.go | 2 +- internal/statesync/stateprovider.go | 2 +- light/provider/mocks/provider.go | 2 +- light/provider/provider.go | 2 +- light/rpc/client.go | 2 +- light/rpc/mocks/light_client.go | 2 +- proxy/app_conn.go | 2 +- proxy/client.go | 2 ++ proxy/mocks/app_conn_consensus.go | 2 +- proxy/mocks/app_conn_mempool.go | 2 +- proxy/mocks/app_conn_query.go | 2 +- proxy/mocks/app_conn_snapshot.go | 2 +- proxy/mocks/client_creator.go | 2 +- rpc/client/interface.go | 2 +- rpc/client/mocks/client.go | 2 +- scripts/mockery_generate.sh | 3 +++ state/indexer/eventsink.go | 2 +- state/indexer/mocks/event_sink.go | 2 +- state/mocks/block_store.go | 2 +- state/mocks/evidence_pool.go | 2 +- state/mocks/store.go | 2 +- state/services.go | 4 ++-- state/store.go | 2 +- tools/tools.go | 1 + 38 files changed, 54 insertions(+), 34 deletions(-) create mode 100755 scripts/mockery_generate.sh diff --git a/Makefile b/Makefile index 871249f56..a509f3a26 100644 --- a/Makefile +++ b/Makefile @@ -237,7 +237,7 @@ build-docker: build-linux ############################################################################### mockery: - go generate -run="mockery" ./... + go generate -run="./scripts/mockery_generate.sh" ./... .PHONY: mockery ############################################################################### diff --git a/abci/client/client.go b/abci/client/client.go index 387fc551a..b6d34e422 100644 --- a/abci/client/client.go +++ b/abci/client/client.go @@ -15,7 +15,7 @@ const ( echoRetryIntervalSeconds = 1 ) -//go:generate mockery --case underscore --name Client +//go:generate ../../scripts/mockery_generate.sh Client // Client defines an interface for an ABCI client. // diff --git a/abci/client/mocks/client.go b/abci/client/mocks/client.go index 621ac1af7..6726ce95e 100644 --- a/abci/client/mocks/client.go +++ b/abci/client/mocks/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/go.mod b/go.mod index a9a9a5370..b6e0fea38 100644 --- a/go.mod +++ b/go.mod @@ -34,6 +34,7 @@ require ( github.com/spf13/viper v1.8.1 github.com/stretchr/testify v1.7.0 github.com/tendermint/tm-db v0.6.4 + github.com/vektra/mockery/v2 v2.9.0 golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 google.golang.org/grpc v1.39.0 diff --git a/go.sum b/go.sum index 29f64f4d3..55e08e088 100644 --- a/go.sum +++ b/go.sum @@ -408,6 +408,7 @@ github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= +github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= @@ -762,6 +763,7 @@ github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/rs/cors v1.8.0 h1:P2KMzcFwrPoSjkF1WLRPsp3UMLyql8L4v9hQpVeK5so= github.com/rs/cors v1.8.0/go.mod h1:EBwu+T5AvHOcXwvZIkQFjUN6s8Czyqw12GL/Y0tUyRM= github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ= +github.com/rs/zerolog v1.18.0/go.mod h1:9nvC1axdVrAHcu/s9taAVfBuIdTZLVQmKQyvrUjF5+I= github.com/rs/zerolog v1.23.0 h1:UskrK+saS9P9Y789yNNulYKdARjPZuS35B8gJF2x60g= github.com/rs/zerolog v1.23.0/go.mod h1:6c7hFfxPOy7TacJc4Fcdi24/J0NKYGzjG8FWRI916Qo= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= @@ -815,6 +817,7 @@ github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng= github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= +github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE= github.com/spf13/cobra v1.1.3/go.mod h1:pGADOWyqRD/YMrPZigI/zbliZ2wVD/23d+is3pSWzOo= github.com/spf13/cobra v1.2.1 h1:+KmjbUw1hriSNMF55oPrkZcb27aECyrj8V2ytv7kWDw= github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= @@ -826,6 +829,7 @@ github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnIn github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= +github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE= github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.7.1/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.8.1 h1:Kq1fyeebqsBfbjZj4EL7gj2IO0mMaiyjYUWcUsl2O44= @@ -873,6 +877,7 @@ github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce/go.mod h1:o8v6yHRoi github.com/tommy-muehle/go-mnd/v2 v2.4.0 h1:1t0f8Uiaq+fqKteUR4N9Umr6E99R+lDnLnq7PwX2PPE= github.com/tommy-muehle/go-mnd/v2 v2.4.0/go.mod h1:WsUAkMJMYww6l/ufffCD3m+P7LEvr8TnZn9lwVDlgzw= github.com/ttacon/chalk v0.0.0-20160626202418-22c06c80ed31/go.mod h1:onvgF043R+lC5RZ8IT9rBXDaEDnpnw/Cl+HFiw+v/7Q= +github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= @@ -888,6 +893,8 @@ github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyC github.com/valyala/fasthttp v1.16.0/go.mod h1:YOKImeEosDdBPnxc0gy7INqi3m1zK6A+xl6TwOBhHCA= github.com/valyala/quicktemplate v1.6.3/go.mod h1:fwPzK2fHuYEODzJ9pkw0ipCPNHZ2tD5KW4lOuSdPKzY= github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio= +github.com/vektra/mockery/v2 v2.9.0 h1:+3FhCL3EviR779mTzXwUuhPNnqFUA7sDnt9OFkXaFd4= +github.com/vektra/mockery/v2 v2.9.0/go.mod h1:2gU4Cf/f8YyC8oEaSXfCnZBMxMjMl/Ko205rlP0fO90= github.com/viki-org/dnscache v0.0.0-20130720023526-c70c1f23c5d8/go.mod h1:dniwbG03GafCjFohMDmz6Zc6oCuiqgH6tGNyXTkHzXE= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs= @@ -902,6 +909,7 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.4/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= @@ -1002,6 +1010,7 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -1135,6 +1144,7 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40 h1:JWgyZ1qgdTaF3N3oxC+MdTV7qvEEgHo3otj+HB5CM7Q= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1171,6 +1181,7 @@ golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgw golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190910044552-dd2b5c81c578/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -1200,6 +1211,7 @@ golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapK golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200323144430-8dcfad9e016e/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= golang.org/x/tools v0.0.0-20200324003944-a576cf524670/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= golang.org/x/tools v0.0.0-20200329025819-fd4102a86c65/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= @@ -1333,6 +1345,7 @@ google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxH google.golang.org/grpc v1.8.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= diff --git a/internal/consensus/mocks/cons_sync_reactor.go b/internal/consensus/mocks/cons_sync_reactor.go index db6afe8df..263969798 100644 --- a/internal/consensus/mocks/cons_sync_reactor.go +++ b/internal/consensus/mocks/cons_sync_reactor.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go index 4a19787c1..2b9fa7358 100644 --- a/internal/consensus/reactor.go +++ b/internal/consensus/reactor.go @@ -112,7 +112,7 @@ type BlockSyncReactor interface { GetRemainingSyncTime() time.Duration } -//go:generate mockery --case underscore --name ConsSyncReactor +//go:generate ../../scripts/mockery_generate.sh ConsSyncReactor // ConsSyncReactor defines an interface used for testing abilities of node.startStateSync. type ConsSyncReactor interface { SwitchToConsensus(sm.State, bool) diff --git a/internal/evidence/mocks/block_store.go b/internal/evidence/mocks/block_store.go index 7cda611d1..ef3346b2a 100644 --- a/internal/evidence/mocks/block_store.go +++ b/internal/evidence/mocks/block_store.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/internal/evidence/services.go b/internal/evidence/services.go index 274433cbe..473999b21 100644 --- a/internal/evidence/services.go +++ b/internal/evidence/services.go @@ -4,7 +4,7 @@ import ( "github.com/tendermint/tendermint/types" ) -//go:generate mockery --case underscore --name BlockStore +//go:generate ../../scripts/mockery_generate.sh BlockStore type BlockStore interface { LoadBlockMeta(height int64) *types.BlockMeta diff --git a/internal/p2p/mocks/connection.go b/internal/p2p/mocks/connection.go index 27b9c24f9..6c6174117 100644 --- a/internal/p2p/mocks/connection.go +++ b/internal/p2p/mocks/connection.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/internal/p2p/mocks/peer.go b/internal/p2p/mocks/peer.go index 80f8e2bf8..b905c1156 100644 --- a/internal/p2p/mocks/peer.go +++ b/internal/p2p/mocks/peer.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/internal/p2p/mocks/transport.go b/internal/p2p/mocks/transport.go index a96204c0c..82bd670cb 100644 --- a/internal/p2p/mocks/transport.go +++ b/internal/p2p/mocks/transport.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/internal/p2p/peer.go b/internal/p2p/peer.go index 7042518eb..709a1294a 100644 --- a/internal/p2p/peer.go +++ b/internal/p2p/peer.go @@ -14,7 +14,7 @@ import ( "github.com/tendermint/tendermint/types" ) -//go:generate mockery --case underscore --name Peer +//go:generate ../../scripts/mockery_generate.sh Peer const metricsTickerDuration = 10 * time.Second diff --git a/internal/p2p/transport.go b/internal/p2p/transport.go index 320b30012..a3245dfc8 100644 --- a/internal/p2p/transport.go +++ b/internal/p2p/transport.go @@ -12,7 +12,7 @@ import ( "github.com/tendermint/tendermint/version" ) -//go:generate mockery --case underscore --name Transport|Connection +//go:generate ../../scripts/mockery_generate.sh Transport|Connection const ( // defaultProtocol is the default protocol used for NodeAddress when diff --git a/internal/statesync/mocks/state_provider.go b/internal/statesync/mocks/state_provider.go index 1e1ec240e..538c619fc 100644 --- a/internal/statesync/mocks/state_provider.go +++ b/internal/statesync/mocks/state_provider.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/internal/statesync/stateprovider.go b/internal/statesync/stateprovider.go index dca1432b1..fd889dc51 100644 --- a/internal/statesync/stateprovider.go +++ b/internal/statesync/stateprovider.go @@ -20,7 +20,7 @@ import ( "github.com/tendermint/tendermint/types" ) -//go:generate mockery --case underscore --name StateProvider +//go:generate ../../scripts/mockery_generate.sh StateProvider // StateProvider is a provider of trusted state data for bootstrapping a node. This refers // to the state.State object, not the state machine. diff --git a/light/provider/mocks/provider.go b/light/provider/mocks/provider.go index aca853667..aa36fa2d3 100644 --- a/light/provider/mocks/provider.go +++ b/light/provider/mocks/provider.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/light/provider/provider.go b/light/provider/provider.go index 14b397543..7f15d5c75 100644 --- a/light/provider/provider.go +++ b/light/provider/provider.go @@ -6,7 +6,7 @@ import ( "github.com/tendermint/tendermint/types" ) -//go:generate mockery --case underscore --name Provider +//go:generate ../../scripts/mockery_generate.sh Provider // Provider provides information for the light client to sync (verification // happens in the client). diff --git a/light/rpc/client.go b/light/rpc/client.go index d8b1e954f..48cf7ce73 100644 --- a/light/rpc/client.go +++ b/light/rpc/client.go @@ -25,7 +25,7 @@ import ( type KeyPathFunc func(path string, key []byte) (merkle.KeyPath, error) // LightClient is an interface that contains functionality needed by Client from the light client. -//go:generate mockery --case underscore --name LightClient +//go:generate ../../scripts/mockery_generate.sh LightClient type LightClient interface { ChainID() string Update(ctx context.Context, now time.Time) (*types.LightBlock, error) diff --git a/light/rpc/mocks/light_client.go b/light/rpc/mocks/light_client.go index f4387a9c7..cc32cf649 100644 --- a/light/rpc/mocks/light_client.go +++ b/light/rpc/mocks/light_client.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/proxy/app_conn.go b/proxy/app_conn.go index 9165bdad4..8eb90daf3 100644 --- a/proxy/app_conn.go +++ b/proxy/app_conn.go @@ -7,7 +7,7 @@ import ( "github.com/tendermint/tendermint/abci/types" ) -//go:generate mockery --case underscore --name AppConnConsensus|AppConnMempool|AppConnQuery|AppConnSnapshot +//go:generate ../scripts/mockery_generate.sh AppConnConsensus|AppConnMempool|AppConnQuery|AppConnSnapshot //---------------------------------------------------------------------------------------- // Enforce which abci msgs can be sent on a connection at the type level diff --git a/proxy/client.go b/proxy/client.go index 928af3cc3..929933e01 100644 --- a/proxy/client.go +++ b/proxy/client.go @@ -10,6 +10,8 @@ import ( tmsync "github.com/tendermint/tendermint/internal/libs/sync" ) +//go:generate ../scripts/mockery_generate.sh ClientCreator + // ClientCreator creates new ABCI clients. type ClientCreator interface { // NewABCIClient returns a new ABCI client. diff --git a/proxy/mocks/app_conn_consensus.go b/proxy/mocks/app_conn_consensus.go index 55157e713..03207706e 100644 --- a/proxy/mocks/app_conn_consensus.go +++ b/proxy/mocks/app_conn_consensus.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/proxy/mocks/app_conn_mempool.go b/proxy/mocks/app_conn_mempool.go index 445163cfd..2505160d6 100644 --- a/proxy/mocks/app_conn_mempool.go +++ b/proxy/mocks/app_conn_mempool.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/proxy/mocks/app_conn_query.go b/proxy/mocks/app_conn_query.go index 207dd5fcf..47ac5bef9 100644 --- a/proxy/mocks/app_conn_query.go +++ b/proxy/mocks/app_conn_query.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/proxy/mocks/app_conn_snapshot.go b/proxy/mocks/app_conn_snapshot.go index a5413cc6e..0b6f10ce1 100644 --- a/proxy/mocks/app_conn_snapshot.go +++ b/proxy/mocks/app_conn_snapshot.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/proxy/mocks/client_creator.go b/proxy/mocks/client_creator.go index 499313d17..0e4157c2f 100644 --- a/proxy/mocks/client_creator.go +++ b/proxy/mocks/client_creator.go @@ -1,4 +1,4 @@ -// Code generated by mockery v1.1.1. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/rpc/client/interface.go b/rpc/client/interface.go index 268b711e7..3547b42ae 100644 --- a/rpc/client/interface.go +++ b/rpc/client/interface.go @@ -29,7 +29,7 @@ import ( "github.com/tendermint/tendermint/types" ) -//go:generate mockery --case underscore --name Client +//go:generate ../../scripts/mockery_generate.sh Client // Client wraps most important rpc calls a client would make if you want to // listen for events, test if it also implements events.EventSwitch. diff --git a/rpc/client/mocks/client.go b/rpc/client/mocks/client.go index 1da390f4b..ef374b9a8 100644 --- a/rpc/client/mocks/client.go +++ b/rpc/client/mocks/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/scripts/mockery_generate.sh b/scripts/mockery_generate.sh new file mode 100755 index 000000000..382c277bb --- /dev/null +++ b/scripts/mockery_generate.sh @@ -0,0 +1,3 @@ +#!/bin/sh + +go run github.com/vektra/mockery/v2 --disable-version-string --case underscore --name $* diff --git a/state/indexer/eventsink.go b/state/indexer/eventsink.go index 19d93e4e5..d7c9d10e0 100644 --- a/state/indexer/eventsink.go +++ b/state/indexer/eventsink.go @@ -16,7 +16,7 @@ const ( PSQL EventSinkType = "psql" ) -//go:generate mockery --case underscore --name EventSink +//go:generate ../../scripts/mockery_generate.sh EventSink // EventSink interface is defined the APIs for the IndexerService to interact with the data store, // including the block/transaction indexing and the search functions. diff --git a/state/indexer/mocks/event_sink.go b/state/indexer/mocks/event_sink.go index 515bb4a0b..ce5b8ace5 100644 --- a/state/indexer/mocks/event_sink.go +++ b/state/indexer/mocks/event_sink.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/state/mocks/block_store.go b/state/mocks/block_store.go index 47d7e26a8..e66aad071 100644 --- a/state/mocks/block_store.go +++ b/state/mocks/block_store.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/state/mocks/evidence_pool.go b/state/mocks/evidence_pool.go index 9d6091cde..bb33547d2 100644 --- a/state/mocks/evidence_pool.go +++ b/state/mocks/evidence_pool.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/state/mocks/store.go b/state/mocks/store.go index a901a2ed1..750bf7f29 100644 --- a/state/mocks/store.go +++ b/state/mocks/store.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery. DO NOT EDIT. package mocks diff --git a/state/services.go b/state/services.go index debd9827b..c692d0b94 100644 --- a/state/services.go +++ b/state/services.go @@ -9,7 +9,7 @@ import ( // NOTE: Interfaces used by RPC must be thread safe! //------------------------------------------------------ -//go:generate mockery --case underscore --name BlockStore +//go:generate ../scripts/mockery_generate.sh BlockStore //------------------------------------------------------ // blockstore @@ -38,7 +38,7 @@ type BlockStore interface { //----------------------------------------------------------------------------- // evidence pool -//go:generate mockery --case underscore --name EvidencePool +//go:generate ../scripts/mockery_generate.sh EvidencePool // EvidencePool defines the EvidencePool interface used by State. type EvidencePool interface { diff --git a/state/store.go b/state/store.go index 0ecd888ca..5ce11e47d 100644 --- a/state/store.go +++ b/state/store.go @@ -68,7 +68,7 @@ func init() { //---------------------- -//go:generate mockery --case underscore --name Store +//go:generate ../scripts/mockery_generate.sh Store // Store defines the state store interface // diff --git a/tools/tools.go b/tools/tools.go index c6f5f4c8c..0e61333ec 100644 --- a/tools/tools.go +++ b/tools/tools.go @@ -8,4 +8,5 @@ package tools import ( _ "github.com/golangci/golangci-lint/cmd/golangci-lint" + _ "github.com/vektra/mockery/v2" ) From dc7c212c41a360bfe6eb38a6dd8c709bbc39aae7 Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Mon, 2 Aug 2021 09:02:43 -0400 Subject: [PATCH 21/35] mempool/v1: test reactor does not panic on broadcast (#6772) This changes adds a failing test for issue #6660. It achieves this by adding a transaction, starting the `broadcastTxRoutine` in a goroutine and then adding another transaction to the mempool. The `broadcastTxRoutine` can receive the second inserted transaction before `insertTx` returns. In that case, `broadcastTxRoutine` will derefence a nil pointer when referencing the `gossipEl` and panic. --- internal/mempool/v1/reactor.go | 9 ++ internal/mempool/v1/reactor_test.go | 147 ++++++++++++++++++++++++++++ 2 files changed, 156 insertions(+) create mode 100644 internal/mempool/v1/reactor_test.go diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go index 9deb7aace..3014e0519 100644 --- a/internal/mempool/v1/reactor.go +++ b/internal/mempool/v1/reactor.go @@ -54,6 +54,10 @@ type Reactor struct { // goroutines. peerWG sync.WaitGroup + // observePanic is a function for observing panics that were recovered in methods on + // Reactor. observePanic is called with the recovered value. + observePanic func(interface{}) + mtx tmsync.Mutex peerRoutines map[types.NodeID]*tmsync.Closer } @@ -77,12 +81,15 @@ func NewReactor( peerUpdates: peerUpdates, closeCh: make(chan struct{}), peerRoutines: make(map[types.NodeID]*tmsync.Closer), + observePanic: defaultObservePanic, } r.BaseService = *service.NewBaseService(logger, "Mempool", r) return r } +func defaultObservePanic(r interface{}) {} + // GetChannelShims returns a map of ChannelDescriptorShim objects, where each // object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding // p2p proto.Message the new p2p Channel is responsible for handling. @@ -188,6 +195,7 @@ func (r *Reactor) handleMempoolMessage(envelope p2p.Envelope) error { func (r *Reactor) handleMessage(chID p2p.ChannelID, envelope p2p.Envelope) (err error) { defer func() { if e := recover(); e != nil { + r.observePanic(e) err = fmt.Errorf("panic in processing message: %v", e) r.Logger.Error( "recovering from processing message panic", @@ -318,6 +326,7 @@ func (r *Reactor) broadcastTxRoutine(peerID types.NodeID, closer *tmsync.Closer) r.peerWG.Done() if e := recover(); e != nil { + r.observePanic(e) r.Logger.Error( "recovering from broadcasting mempool loop", "err", e, diff --git a/internal/mempool/v1/reactor_test.go b/internal/mempool/v1/reactor_test.go new file mode 100644 index 000000000..5934d534c --- /dev/null +++ b/internal/mempool/v1/reactor_test.go @@ -0,0 +1,147 @@ +package v1 + +import ( + "os" + "strings" + "sync" + "testing" + + "github.com/stretchr/testify/require" + "github.com/tendermint/tendermint/abci/example/kvstore" + "github.com/tendermint/tendermint/config" + tmsync "github.com/tendermint/tendermint/internal/libs/sync" + "github.com/tendermint/tendermint/internal/mempool" + "github.com/tendermint/tendermint/internal/p2p" + "github.com/tendermint/tendermint/internal/p2p/p2ptest" + "github.com/tendermint/tendermint/libs/log" + protomem "github.com/tendermint/tendermint/proto/tendermint/mempool" + "github.com/tendermint/tendermint/types" +) + +type reactorTestSuite struct { + network *p2ptest.Network + logger log.Logger + + reactors map[types.NodeID]*Reactor + mempoolChannels map[types.NodeID]*p2p.Channel + mempools map[types.NodeID]*TxMempool + kvstores map[types.NodeID]*kvstore.Application + + peerChans map[types.NodeID]chan p2p.PeerUpdate + peerUpdates map[types.NodeID]*p2p.PeerUpdates + + nodes []types.NodeID +} + +func setupReactors(t *testing.T, numNodes int, chBuf uint) *reactorTestSuite { + t.Helper() + + cfg := config.ResetTestRoot(strings.ReplaceAll(t.Name(), "/", "|")) + t.Cleanup(func() { + os.RemoveAll(cfg.RootDir) + }) + + rts := &reactorTestSuite{ + logger: log.TestingLogger().With("testCase", t.Name()), + network: p2ptest.MakeNetwork(t, p2ptest.NetworkOptions{NumNodes: numNodes}), + reactors: make(map[types.NodeID]*Reactor, numNodes), + mempoolChannels: make(map[types.NodeID]*p2p.Channel, numNodes), + mempools: make(map[types.NodeID]*TxMempool, numNodes), + kvstores: make(map[types.NodeID]*kvstore.Application, numNodes), + peerChans: make(map[types.NodeID]chan p2p.PeerUpdate, numNodes), + peerUpdates: make(map[types.NodeID]*p2p.PeerUpdates, numNodes), + } + + chDesc := p2p.ChannelDescriptor{ID: byte(mempool.MempoolChannel)} + rts.mempoolChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(protomem.Message), int(chBuf)) + + for nodeID := range rts.network.Nodes { + rts.kvstores[nodeID] = kvstore.NewApplication() + + mempool := setup(t, 0) + rts.mempools[nodeID] = mempool + + rts.peerChans[nodeID] = make(chan p2p.PeerUpdate) + rts.peerUpdates[nodeID] = p2p.NewPeerUpdates(rts.peerChans[nodeID], 1) + rts.network.Nodes[nodeID].PeerManager.Register(rts.peerUpdates[nodeID]) + + rts.reactors[nodeID] = NewReactor( + rts.logger.With("nodeID", nodeID), + cfg.Mempool, + rts.network.Nodes[nodeID].PeerManager, + mempool, + rts.mempoolChannels[nodeID], + rts.peerUpdates[nodeID], + ) + + rts.nodes = append(rts.nodes, nodeID) + + require.NoError(t, rts.reactors[nodeID].Start()) + require.True(t, rts.reactors[nodeID].IsRunning()) + } + + require.Len(t, rts.reactors, numNodes) + + t.Cleanup(func() { + for nodeID := range rts.reactors { + if rts.reactors[nodeID].IsRunning() { + require.NoError(t, rts.reactors[nodeID].Stop()) + require.False(t, rts.reactors[nodeID].IsRunning()) + } + } + }) + + return rts +} + +func (rts *reactorTestSuite) start(t *testing.T) { + t.Helper() + rts.network.Start(t) + require.Len(t, + rts.network.RandomNode().PeerManager.Peers(), + len(rts.nodes)-1, + "network does not have expected number of nodes") +} + +func TestReactorBroadcastDoesNotPanic(t *testing.T) { + numNodes := 2 + rts := setupReactors(t, numNodes, 0) + + observePanic := func(r interface{}) { + t.Fatal("panic detected in reactor") + } + + primary := rts.nodes[0] + secondary := rts.nodes[1] + primaryReactor := rts.reactors[primary] + primaryMempool := primaryReactor.mempool + secondaryReactor := rts.reactors[secondary] + + primaryReactor.observePanic = observePanic + secondaryReactor.observePanic = observePanic + + firstTx := &WrappedTx{} + primaryMempool.insertTx(firstTx) + + // run the router + rts.start(t) + + closer := tmsync.NewCloser() + primaryReactor.peerWG.Add(1) + go primaryReactor.broadcastTxRoutine(secondary, closer) + + wg := &sync.WaitGroup{} + for i := 0; i < 50; i++ { + next := &WrappedTx{} + wg.Add(1) + go func() { + defer wg.Done() + primaryMempool.insertTx(next) + }() + } + + err := primaryReactor.Stop() + require.NoError(t, err) + primaryReactor.peerWG.Wait() + wg.Wait() +} From e9220161210deacb5cc105c263be9d4616b7387a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 2 Aug 2021 12:25:37 -0400 Subject: [PATCH 22/35] build(deps): Bump technote-space/get-diff-action from 4 to 5 (#6788) Bumps [technote-space/get-diff-action](https://github.com/technote-space/get-diff-action) from 4 to 5. - [Release notes](https://github.com/technote-space/get-diff-action/releases) - [Changelog](https://github.com/technote-space/get-diff-action/blob/main/.releasegarc) - [Commits](https://github.com/technote-space/get-diff-action/compare/v4...v5) --- updated-dependencies: - dependency-name: technote-space/get-diff-action dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Aleksandr Bezobchuk --- .github/workflows/coverage.yml | 6 +++--- .github/workflows/e2e.yml | 2 +- .github/workflows/lint.yml | 2 +- .github/workflows/tests.yml | 6 +++--- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 7d7ab8113..12dd504e3 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -46,7 +46,7 @@ jobs: with: go-version: "1.16" - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go @@ -68,7 +68,7 @@ jobs: with: go-version: "1.16" - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go @@ -96,7 +96,7 @@ jobs: needs: tests steps: - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml index 7fc3cde7a..dd2b44da3 100644 --- a/.github/workflows/e2e.yml +++ b/.github/workflows/e2e.yml @@ -18,7 +18,7 @@ jobs: with: go-version: '1.16' - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 4b0092afc..79cb3685b 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -14,7 +14,7 @@ jobs: timeout-minutes: 8 steps: - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 14bb8570b..14d531812 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -19,7 +19,7 @@ jobs: with: go-version: "1.16" - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go @@ -51,7 +51,7 @@ jobs: with: go-version: "1.16" - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go @@ -82,7 +82,7 @@ jobs: with: go-version: "1.16" - uses: actions/checkout@v2.3.4 - - uses: technote-space/get-diff-action@v4 + - uses: technote-space/get-diff-action@v5 with: PATTERNS: | **/**.go From e5f9dd2736db260b7bf223b659c17976d7b2a5b0 Mon Sep 17 00:00:00 2001 From: rene <41963722+renaynay@users.noreply.github.com> Date: Mon, 2 Aug 2021 23:25:59 +0200 Subject: [PATCH 23/35] docs: fix typo (#6789) --- UPGRADING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UPGRADING.md b/UPGRADING.md index cc721af8e..ef0a29fb4 100644 --- a/UPGRADING.md +++ b/UPGRADING.md @@ -27,7 +27,7 @@ This guide provides instructions for upgrading to specific versions of Tendermin * `BootstrapPeers` has been added as part of the new p2p stack. This will eventually replace `Seeds`. Bootstrap peers are connected with on startup if needed for peer discovery. Unlike - persistent peers, there's no gaurantee that the node will remain connected with these peers. + persistent peers, there's no guarantee that the node will remain connected with these peers. * configuration values starting with `priv-validator-` have moved to the new `priv-validator` section, without the `priv-validator-` prefix. From 4cbaf70d1fe5f0a9ee32efcdf6a6d13dde4924f1 Mon Sep 17 00:00:00 2001 From: "M. J. Fromberger" Date: Tue, 3 Aug 2021 12:08:23 -0700 Subject: [PATCH 24/35] docs: fix a typo in the genesis_chunked description (#6792) --- rpc/openapi/openapi.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rpc/openapi/openapi.yaml b/rpc/openapi/openapi.yaml index bb35d34ac..bfd49b461 100644 --- a/rpc/openapi/openapi.yaml +++ b/rpc/openapi/openapi.yaml @@ -837,7 +837,7 @@ paths: - Info description: | Get genesis document in a paginated/chunked format to make it - easier to iterate through larger gensis structures. + easier to iterate through larger genesis structures. parameters: - in: query name: chunkID @@ -1946,14 +1946,14 @@ components: - "chunk" - "total" - "data" - properties: + properties: chunk: type: integer example: 0 total: type: integer example: 1 - data: + data: type: string example: "Z2VuZXNpcwo=" From e8013281281985e3ada7819f42502b09623d24a0 Mon Sep 17 00:00:00 2001 From: William Banfield <4561443+williambanfield@users.noreply.github.com> Date: Tue, 3 Aug 2021 15:30:05 -0400 Subject: [PATCH 25/35] clist: add simple property tests (#6791) Adds a simple property test to the `clist` package. This test uses the [rapid](https://github.com/flyingmutant/rapid) library and works by modeling the internal clist as a simple array. Follow up from this mornings workshop with the Regen team. --- go.mod | 1 + go.sum | 2 + internal/libs/clist/clist_property_test.go | 72 ++++++++++++++++++++++ 3 files changed, 75 insertions(+) create mode 100644 internal/libs/clist/clist_property_test.go diff --git a/go.mod b/go.mod index b6e0fea38..d13c9ea4b 100644 --- a/go.mod +++ b/go.mod @@ -39,4 +39,5 @@ require ( golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 google.golang.org/grpc v1.39.0 gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect + pgregory.net/rapid v0.4.7 // indirect ) diff --git a/go.sum b/go.sum index 55e08e088..ed2f127b2 100644 --- a/go.sum +++ b/go.sum @@ -1437,6 +1437,8 @@ mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b h1:DxJ5nJdkhDlLok9K6qO+5290kphD mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b/go.mod h1:2odslEg/xrtNQqCYg2/jCoyKnw3vv5biOc3JnIcYfL4= mvdan.cc/unparam v0.0.0-20210104141923-aac4ce9116a7 h1:HT3e4Krq+IE44tiN36RvVEb6tvqeIdtsVSsxmNPqlFU= mvdan.cc/unparam v0.0.0-20210104141923-aac4ce9116a7/go.mod h1:hBpJkZE8H/sb+VRFvw2+rBpHNsTBcvSpk61hr8mzXZE= +pgregory.net/rapid v0.4.7 h1:MTNRktPuv5FNqOO151TM9mDTa+XHcX6ypYeISDVD14g= +pgregory.net/rapid v0.4.7/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= diff --git a/internal/libs/clist/clist_property_test.go b/internal/libs/clist/clist_property_test.go new file mode 100644 index 000000000..cdc173ee5 --- /dev/null +++ b/internal/libs/clist/clist_property_test.go @@ -0,0 +1,72 @@ +package clist_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + "pgregory.net/rapid" + + "github.com/tendermint/tendermint/internal/libs/clist" +) + +func TestCListProperties(t *testing.T) { + rapid.Check(t, rapid.Run(&clistModel{})) +} + +// clistModel is used by the rapid state machine testing framework. +// clistModel contains both the clist that is being tested and a slice of *clist.CElements +// that will be used to model the expected clist behavior. +type clistModel struct { + clist *clist.CList + + model []*clist.CElement +} + +// Init is a method used by the rapid state machine testing library. +// Init is called when the test starts to initialize the data that will be used +// in the state machine test. +func (m *clistModel) Init(t *rapid.T) { + m.clist = clist.New() + m.model = []*clist.CElement{} +} + +// PushBack defines an action that will be randomly selected across by the rapid state +// machines testing library. Every call to PushBack calls PushBack on the clist and +// performs a similar action on the model data. +func (m *clistModel) PushBack(t *rapid.T) { + value := rapid.String().Draw(t, "value").(string) + el := m.clist.PushBack(value) + m.model = append(m.model, el) +} + +// Remove defines an action that will be randomly selected across by the rapid state +// machine testing library. Every call to Remove selects an element from the model +// and calls Remove on the CList with that element. The same element is removed from +// the model to keep the objects in sync. +func (m *clistModel) Remove(t *rapid.T) { + if len(m.model) == 0 { + return + } + ix := rapid.IntRange(0, len(m.model)-1).Draw(t, "index").(int) + value := m.model[ix] + m.model = append(m.model[:ix], m.model[ix+1:]...) + m.clist.Remove(value) +} + +// Check is a method required by the rapid state machine testing library. +// Check is run after each action and is used to verify that the state of the object, +// in this case a clist.CList matches the state of the objec. +func (m *clistModel) Check(t *rapid.T) { + require.Equal(t, len(m.model), m.clist.Len()) + if len(m.model) == 0 { + return + } + require.Equal(t, m.model[0], m.clist.Front()) + require.Equal(t, m.model[len(m.model)-1], m.clist.Back()) + + iter := m.clist.Front() + for _, val := range m.model { + require.Equal(t, val, iter) + iter = iter.Next() + } +} From 4db71da68e82d5cb732b235eeb2fd69d62114b45 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 5 Aug 2021 10:08:49 -0400 Subject: [PATCH 26/35] build(deps): Bump github.com/BurntSushi/toml from 0.3.1 to 0.4.1 (#6796) Bumps [github.com/BurntSushi/toml](https://github.com/BurntSushi/toml) from 0.3.1 to 0.4.1. - [Release notes](https://github.com/BurntSushi/toml/releases) - [Commits](https://github.com/BurntSushi/toml/compare/v0.3.1...v0.4.1) --- updated-dependencies: - dependency-name: github.com/BurntSushi/toml dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- go.mod | 4 ++-- go.sum | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index d13c9ea4b..cb49f948e 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,7 @@ module github.com/tendermint/tendermint go 1.16 require ( - github.com/BurntSushi/toml v0.3.1 + github.com/BurntSushi/toml v0.4.1 github.com/Masterminds/squirrel v1.5.0 github.com/Workiva/go-datastructures v1.0.53 github.com/adlio/schema v1.1.13 @@ -39,5 +39,5 @@ require ( golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 google.golang.org/grpc v1.39.0 gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect - pgregory.net/rapid v0.4.7 // indirect + pgregory.net/rapid v0.4.7 ) diff --git a/go.sum b/go.sum index ed2f127b2..0bbb1f3e6 100644 --- a/go.sum +++ b/go.sum @@ -46,8 +46,9 @@ contrib.go.opencensus.io/exporter/stackdriver v0.13.4/go.mod h1:aXENhDJ1Y4lIg4EU dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 h1:w+iIsaOQNcT7OZ575w+acHgRric5iCyQh+xv+KJ4HB8= github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= -github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v0.4.1 h1:GaI7EiDXDRfa8VshkTj7Fym7ha+y8/XxIgD2okUIjLw= +github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/DataDog/zstd v1.4.1 h1:3oxKN3wbHibqx897utPC2LTQU4J+IHWWJO+glkAkpFM= github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= From e5312942e30331e7c42b75426da2c6c9c00ae476 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 6 Aug 2021 14:28:58 +0000 Subject: [PATCH 27/35] build(deps): Bump google.golang.org/grpc from 1.39.0 to 1.39.1 (#6801) Bumps [google.golang.org/grpc](https://github.com/grpc/grpc-go) from 1.39.0 to 1.39.1.
Release notes

Sourced from google.golang.org/grpc's releases.

Release 1.39.1

  • server: fix bug that net.Conn is leaked if the connection is closed (io.EOF) immediately with no traffic (#4642)
  • transport: fix race in transport stream accessing s.recvCompress (#4627)
Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=google.golang.org/grpc&package-manager=go_modules&previous-version=1.39.0&new-version=1.39.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- go.mod | 2 +- go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index cb49f948e..a23bc5167 100644 --- a/go.mod +++ b/go.mod @@ -37,7 +37,7 @@ require ( github.com/vektra/mockery/v2 v2.9.0 golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 - google.golang.org/grpc v1.39.0 + google.golang.org/grpc v1.39.1 gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect pgregory.net/rapid v0.4.7 ) diff --git a/go.sum b/go.sum index 0bbb1f3e6..3e20b60ab 100644 --- a/go.sum +++ b/go.sum @@ -1368,8 +1368,8 @@ google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= -google.golang.org/grpc v1.39.0 h1:Klz8I9kdtkIN6EpHHUOMLCYhTn/2WAe5a0s1hcBkdTI= -google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.39.1 h1:f37vZbBVTiJ6jKG5mWz8ySOBxNqy6ViPgyhSdVnxF3E= +google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= From 31994cadc0f89d8cd57c23cd5400a6ed039b8acc Mon Sep 17 00:00:00 2001 From: Sam Kleinman Date: Fri, 6 Aug 2021 15:51:07 -0400 Subject: [PATCH 28/35] docs: upgrade documentation for custom mempools (#6794) This is proposed language for the upgrade process about the new custom reactor/mempool support. --- UPGRADING.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/UPGRADING.md b/UPGRADING.md index ef0a29fb4..82b792515 100644 --- a/UPGRADING.md +++ b/UPGRADING.md @@ -81,6 +81,16 @@ will need to change to accommodate these changes. Most notably: Mark gRPC in the RPC layer as deprecated and to be removed in 0.36. +### Support for Custom Reactor and Mempool Implementations + +The changes to p2p layer removed existing support for custom +reactors. Based on our understanding of how this functionality was +used, the introduction of the prioritized mempool covers nearly all of +the use cases for custom reactors. If you are currently running custom +reactors and mempools and are having trouble seeing the migration path +for your project please feel free to reach out to the Tendermint Core +development team directly. + ## v0.34.0 **Upgrading to Tendermint 0.34 requires a blockchain restart.** From a7ecf49c10bd67b3738dd4bb5138b657ef9844f8 Mon Sep 17 00:00:00 2001 From: "M. J. Fromberger" Date: Mon, 9 Aug 2021 20:30:58 -0700 Subject: [PATCH 29/35] Add new team member to CODEOWNERS. (#6811) --- .github/CODEOWNERS | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 30218e098..7993419e8 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -7,5 +7,4 @@ # global owners are only requested if there isn't a more specific # codeowner specified below. For this reason, the global codeowners # are often repeated in package-level definitions. -* @alexanderbez @ebuchman @cmwaters @tessr @tychoish @williambanfield - +* @alexanderbez @ebuchman @cmwaters @tessr @tychoish @williambanfield @creachadair From 53d53e62052f7ab0d6473a84ca7ed726e4bd6dba Mon Sep 17 00:00:00 2001 From: "M. J. Fromberger" Date: Tue, 10 Aug 2021 06:58:18 -0700 Subject: [PATCH 30/35] bytes: clean up and simplify encoding of HexBytes (#6810) As written, the encoding step unnecessarily made and moved multiple copies of the encoded representation. Reduce this to a single allocation and encode the data in-place so that a shift is no longer required. Also: Add a test to ensure letter digits are capitalized, which was previously not verified but was expected downstream. No functional changes. --- libs/bytes/bytes.go | 23 +++++++++++++++-------- libs/bytes/bytes_test.go | 1 + 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/libs/bytes/bytes.go b/libs/bytes/bytes.go index cfb7a8db2..dd8e39737 100644 --- a/libs/bytes/bytes.go +++ b/libs/bytes/bytes.go @@ -27,15 +27,22 @@ func (bz *HexBytes) Unmarshal(data []byte) error { return nil } -// MarshalJSON implements the json.Marshaler interface. The hex bytes is a -// quoted hexadecimal encoded string. +// MarshalJSON implements the json.Marshaler interface. The encoding is a JSON +// quoted string of hexadecimal digits. func (bz HexBytes) MarshalJSON() ([]byte, error) { - s := strings.ToUpper(hex.EncodeToString(bz)) - jbz := make([]byte, len(s)+2) - jbz[0] = '"' - copy(jbz[1:], s) - jbz[len(jbz)-1] = '"' - return jbz, nil + size := hex.EncodedLen(len(bz)) + 2 // +2 for quotation marks + buf := make([]byte, size) + hex.Encode(buf[1:], []byte(bz)) + buf[0] = '"' + buf[size-1] = '"' + + // Ensure letter digits are capitalized. + for i := 1; i < size-1; i++ { + if buf[i] >= 'a' && buf[i] <= 'f' { + buf[i] = 'A' + (buf[i] - 'a') + } + } + return buf, nil } // UnmarshalJSON implements the json.Umarshaler interface. diff --git a/libs/bytes/bytes_test.go b/libs/bytes/bytes_test.go index db882f1c1..6a9ca7c3d 100644 --- a/libs/bytes/bytes_test.go +++ b/libs/bytes/bytes_test.go @@ -37,6 +37,7 @@ func TestJSONMarshal(t *testing.T) { {[]byte(``), `{"B1":"","B2":""}`}, {[]byte(`a`), `{"B1":"YQ==","B2":"61"}`}, {[]byte(`abc`), `{"B1":"YWJj","B2":"616263"}`}, + {[]byte("\x1a\x2b\x3c"), `{"B1":"Gis8","B2":"1A2B3C"}`}, } for i, tc := range cases { From 66084a01dc6ecb9ad4692adaa6cfc3677899d8b6 Mon Sep 17 00:00:00 2001 From: Sam Kleinman Date: Tue, 10 Aug 2021 14:58:21 -0400 Subject: [PATCH 31/35] commands: add key migration cli (#6790) --- UPGRADING.md | 77 ++++++++++++++++---------- cmd/tendermint/commands/key_migrate.go | 64 +++++++++++++++++++++ cmd/tendermint/commands/run_node.go | 5 +- cmd/tendermint/main.go | 1 + 4 files changed, 118 insertions(+), 29 deletions(-) create mode 100644 cmd/tendermint/commands/key_migrate.go diff --git a/UPGRADING.md b/UPGRADING.md index 82b792515..e53c34c29 100644 --- a/UPGRADING.md +++ b/UPGRADING.md @@ -24,10 +24,10 @@ This guide provides instructions for upgrading to specific versions of Tendermin * Added `--mode` flag and `mode` config variable on `config.toml` for setting Mode of the Node: `full` | `validator` | `seed` (default: `full`) [ADR-52](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-052-tendermint-mode.md) - + * `BootstrapPeers` has been added as part of the new p2p stack. This will eventually replace `Seeds`. Bootstrap peers are connected with on startup if needed for peer discovery. Unlike - persistent peers, there's no guarantee that the node will remain connected with these peers. + persistent peers, there's no gaurantee that the node will remain connected with these peers. * configuration values starting with `priv-validator-` have moved to the new `priv-validator` section, without the `priv-validator-` prefix. @@ -35,6 +35,27 @@ This guide provides instructions for upgrading to specific versions of Tendermin * The fast sync process as well as the blockchain package and service has all been renamed to block sync +### Key Format Changes + +The format of all tendermint on-disk database keys changes in +0.35. Upgrading nodes must either re-sync all data or run a migration +script provided in this release. The script located in +`github.com/tendermint/tendermint/scripts/keymigrate/migrate.go` +provides the function `Migrate(context.Context, db.DB)` which you can +operationalize as makes sense for your deployment. + +For ease of use the `tendermint` command includes a CLI version of the +migration script, which you can invoke, as in: + + tendermint key-migrate + +This reads the configuration file as normal and allows the +`--db-backend` and `--db-dir` flags to change database operations as +needed. + +The migration operation is idempotent and can be run more than once, +if needed. + ### CLI Changes * You must now specify the node mode (validator|full|seed) in `tendermint init [mode]` @@ -66,7 +87,7 @@ are: - `blockchain` - `evidence` -Accordingly, the space `node` package was changed to reduce access to +Accordingly, the `node` package was changed to reduce access to tendermint internals: applications that use tendermint as a library will need to change to accommodate these changes. Most notably: @@ -244,8 +265,8 @@ Other user-relevant changes include: * The old `lite` package was removed; the new light client uses the `light` package. * The `Verifier` was broken up into two pieces: - * Core verification logic (pure `VerifyX` functions) - * `Client` object, which represents the complete light client + * Core verification logic (pure `VerifyX` functions) + * `Client` object, which represents the complete light client * The new light clients stores headers & validator sets as `LightBlock`s * The RPC client can be found in the `/rpc` directory. * The HTTP(S) proxy is located in the `/proxy` directory. @@ -377,12 +398,12 @@ Evidence Params has been changed to include duration. ### Go API * `libs/common` has been removed in favor of specific pkgs. - * `async` - * `service` - * `rand` - * `net` - * `strings` - * `cmap` + * `async` + * `service` + * `rand` + * `net` + * `strings` + * `cmap` * removal of `errors` pkg ### RPC Changes @@ -451,9 +472,9 @@ Prior to the update, suppose your `ResponseDeliverTx` look like: ```go abci.ResponseDeliverTx{ Tags: []kv.Pair{ - {Key: []byte("sender"), Value: []byte("foo")}, - {Key: []byte("recipient"), Value: []byte("bar")}, - {Key: []byte("amount"), Value: []byte("35")}, + {Key: []byte("sender"), Value: []byte("foo")}, + {Key: []byte("recipient"), Value: []byte("bar")}, + {Key: []byte("amount"), Value: []byte("35")}, } } ``` @@ -472,14 +493,14 @@ the following `Events`: ```go abci.ResponseDeliverTx{ Events: []abci.Event{ - { - Type: "transfer", - Attributes: kv.Pairs{ - {Key: []byte("sender"), Value: []byte("foo")}, - {Key: []byte("recipient"), Value: []byte("bar")}, - {Key: []byte("amount"), Value: []byte("35")}, - }, - } + { + Type: "transfer", + Attributes: kv.Pairs{ + {Key: []byte("sender"), Value: []byte("foo")}, + {Key: []byte("recipient"), Value: []byte("bar")}, + {Key: []byte("amount"), Value: []byte("35")}, + }, + } } ``` @@ -527,9 +548,9 @@ In this case, the WS client will receive an error with description: "jsonrpc": "2.0", "id": "{ID}#event", "error": { - "code": -32000, - "msg": "Server error", - "data": "subscription was canceled (reason: client is not pulling messages fast enough)" // or "subscription was canceled (reason: Tendermint exited)" + "code": -32000, + "msg": "Server error", + "data": "subscription was canceled (reason: client is not pulling messages fast enough)" // or "subscription was canceled (reason: Tendermint exited)" } } @@ -735,9 +756,9 @@ just the `Data` field set: ```go []ProofOp{ - ProofOp{ - Data: , - } + ProofOp{ + Data: , + } } ``` diff --git a/cmd/tendermint/commands/key_migrate.go b/cmd/tendermint/commands/key_migrate.go new file mode 100644 index 000000000..739af4a7d --- /dev/null +++ b/cmd/tendermint/commands/key_migrate.go @@ -0,0 +1,64 @@ +package commands + +import ( + "context" + "fmt" + + "github.com/spf13/cobra" + cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/scripts/keymigrate" +) + +func MakeKeyMigrateCommand() *cobra.Command { + cmd := &cobra.Command{ + Use: "key-migrate", + Short: "Run Database key migration", + RunE: func(cmd *cobra.Command, args []string) error { + ctx, cancel := context.WithCancel(cmd.Context()) + defer cancel() + + contexts := []string{ + // this is ordered to put the + // (presumably) biggest/most important + // subsets first. + "blockstore", + "state", + "peerstore", + "tx_index", + "evidence", + "light", + } + + for idx, dbctx := range contexts { + logger.Info("beginning a key migration", + "dbctx", dbctx, + "num", idx+1, + "total", len(contexts), + ) + + db, err := cfg.DefaultDBProvider(&cfg.DBContext{ + ID: dbctx, + Config: config, + }) + + if err != nil { + return fmt.Errorf("constructing database handle: %w", err) + } + + if err = keymigrate.Migrate(ctx, db); err != nil { + return fmt.Errorf("running migration for context %q: %w", + dbctx, err) + } + } + + logger.Info("completed database migration successfully") + + return nil + }, + } + + // allow database info to be overridden via cli + addDBFlags(cmd) + + return cmd +} diff --git a/cmd/tendermint/commands/run_node.go b/cmd/tendermint/commands/run_node.go index 1c68fcffe..97d6197a2 100644 --- a/cmd/tendermint/commands/run_node.go +++ b/cmd/tendermint/commands/run_node.go @@ -83,7 +83,10 @@ func AddNodeFlags(cmd *cobra.Command) { config.Consensus.CreateEmptyBlocksInterval.String(), "the possible interval between empty blocks") - // db flags + addDBFlags(cmd) +} + +func addDBFlags(cmd *cobra.Command) { cmd.Flags().String( "db-backend", config.DBBackend, diff --git a/cmd/tendermint/main.go b/cmd/tendermint/main.go index b40624cc3..b092f5645 100644 --- a/cmd/tendermint/main.go +++ b/cmd/tendermint/main.go @@ -28,6 +28,7 @@ func main() { cmd.ShowNodeIDCmd, cmd.GenNodeKeyCmd, cmd.VersionCmd, + cmd.MakeKeyMigrateCommand(), debug.DebugCmd, cli.NewCompletionCmd(rootCmd, true), ) From 97435139ade70d17f85384a7873c82c2dc750c0f Mon Sep 17 00:00:00 2001 From: Sam Kleinman Date: Wed, 11 Aug 2021 10:34:45 -0400 Subject: [PATCH 32/35] adr: node initialization (#6562) --- docs/architecture/README.md | 1 + .../adr-069-flexible-node-intitalization.md | 273 ++++++++++++++++++ .../architecture/img/consensus_blockchain.png | Bin 0 -> 687838 bytes 3 files changed, 274 insertions(+) create mode 100644 docs/architecture/adr-069-flexible-node-intitalization.md create mode 100644 docs/architecture/img/consensus_blockchain.png diff --git a/docs/architecture/README.md b/docs/architecture/README.md index a4e326274..7025a72f6 100644 --- a/docs/architecture/README.md +++ b/docs/architecture/README.md @@ -97,3 +97,4 @@ Note the context/background should be written in the present tense. - [ADR-041: Proposer-Selection-via-ABCI](./adr-041-proposer-selection-via-abci.md) - [ADR-045: ABCI-Evidence](./adr-045-abci-evidence.md) - [ADR-057: RPC](./adr-057-RPC.md) +- [ADR-069: Node Initialization](./adr-069-flexible-node-initialization.md) diff --git a/docs/architecture/adr-069-flexible-node-intitalization.md b/docs/architecture/adr-069-flexible-node-intitalization.md new file mode 100644 index 000000000..ec66725be --- /dev/null +++ b/docs/architecture/adr-069-flexible-node-intitalization.md @@ -0,0 +1,273 @@ +# ADR 069: Flexible Node Initialization + +## Changlog + +- 2021-06-09: Initial Draft (@tychoish) + +- 2021-07-21: Major Revision (@tychoish) + +## Status + +Proposed. + +## Context + +In an effort to support [Go-API-Stability](./adr-060-go-api-stability.md), +during the 0.35 development cycle, we have attempted to reduce the the API +surface area by moving most of the interface of the `node` package into +unexported functions, as well as moving the reactors to an `internal` +package. Having this coincide with the 0.35 release made a lot of sense +because these interfaces were _already_ changing as a result of the `p2p` +[refactor](./adr-061-p2p-refactor-scope.md), so it made sense to think a bit +more about how tendermint exposes this API. + +While the interfaces of the P2P layer and most of the node package are already +internalized, this precludes some operational patterns that are important to +users who use tendermint as a library. Specifically, introspecting the +tendermint node service and replacing components is not supported in the latest +version of the code, and some of these use cases would require maintaining a +vendor copy of the code. Adding these features requires rather extensive +(internal/implementation) changes to the `node` and `rpc` packages, and this +ADR describes a model for changing the way that tendermint nodes initialize, in +service of providing this kind of functionality. + +We consider node initialization, because the current implemention +provides strong connections between all components, as well as between +the components of the node and the RPC layer, and being able to think +about the interactions of these components will help enable these +features and help define the requirements of the node package. + +## Alternative Approaches + +These alternatives are presented to frame the design space and to +contextualize the decision in terms of product requirements. These +ideas are not inherently bad, and may even be possible or desireable +in the (distant) future, and merely provide additional context for how +we, in the moment came to our decision(s). + +### Do Nothing + +The current implementation is functional and sufficient for the vast +majority of use cases (e.g., all users of the Cosmos-SDK as well as +anyone who runs tendermint and the ABCI application in separate +processes). In the current implementation, and even previous versions, +modifying node initialization or injecting custom components required +copying most of the `node` package, which required such users +to maintain a vendored copy of tendermint. + +While this is (likely) not tenable in the long term, as users do want +more modularity, and the current service implementation is brittle and +difficult to maintain, in the short term it may be possible to delay +implementation somewhat. Eventually, however, we will need to make the +`node` package easier to maintain and reason about. + +### Generic Service Pluggability + +One possible system design would export interfaces (in the Golang +sense) for all components of the system, to permit runtime dependency +injection of all components in the system, so that users can compose +tendermint nodes of arbitrary user-supplied components. + +Although this level of customization would provide benefits, it would be a huge +undertaking (particularly with regards to API design work) that we do not have +scope for at the moment. Eventually providing support for some kinds of +pluggability may be useful, so the current solution does not explicitly +foreclose the possibility of this alternative. + +### Abstract Dependency Based Startup and Shutdown + +The main proposal in this document makes tendermint node initialization simpler +and more abstract, but the system lacks a number of +features which daemon/service initialization could provide, such as a +system allowing the authors of services to control initialization and shutdown order +of components using dependency relationships. + +Such a system could work by allowing services to declare +initialization order dependencies to other reactors (by ID, perhaps) +so that the node could decide the initialization based on the +dependencies declared by services rather than requiring the node to +encode this logic directly. + +This level of configuration is probably more complicated than is needed. Given +that the authors of components in the current implementation of tendermint +already *do* need to know about other components, a dependency-based system +would probably be overly-abstract at this stage. + +## Decisions + +- To the greatest extent possible, factor the code base so that + packages are responsible for their own initialization, and minimize + the amount of code in the `node` package itself. + +- As a design goal, reduce direct coupling and dependencies between + components in the implementation of `node`. + +- Begin iterating on a more-flexible internal framework for + initializing tendermint nodes to make the initatilization process + less hard-coded by the implementation of the node objects. + + - Reactors should not need to expose their interfaces *within* the + implementation of the node type + + - This refactoring should be entirely opaque to users. + + - These node initialization changes should not require a + reevaluation of the `service.Service` or a generic initialization + orchestration framework. + +- Do not proactively provide a system for injecting + components/services within a tendtermint node, though make it + possible to retrofit this kind of plugability in the future if + needed. + +- Prioritize implementation of p2p-based statesync reactor to obviate + need for users to inject a custom state-sync provider. + +## Detailed Design + +The [current +nodeImpl](https://github.com/tendermint/tendermint/blob/master/node/node.go#L47) +includes direct references to the implementations of each of the +reactors, which should be replaced by references to `service.Service` +objects. This will require moving construction of the [rpc +service](https://github.com/tendermint/tendermint/blob/master/node/node.go#L771) +into the constructor of +[makeNode](https://github.com/tendermint/tendermint/blob/master/node/node.go#L126). One +possible implementation of this would be to eliminate the current +`ConfigureRPC` method on the node package and instead [configure it +here](https://github.com/tendermint/tendermint/pull/6798/files#diff-375d57e386f20eaa5f09f02bb9d28bfc48ac3dca18d0325f59492208219e5618R441). + +To avoid adding complexity to the `node` package, we will add a +composite service implementation to the `service` package +that implements `service.Service` and is composed of a sequence of +underlying `service.Service` objects and handles their +startup/shutdown in the specified sequential order. + +Consensus, blocksync (*née* fast sync), and statesync all depend on +each other, and have significant initialization dependencies that are +presently encoded in the `node` package. As part of this change, a +new package/component (likely named `blocks` located at +`internal/blocks`) will encapsulate the initialization of these block +management areas of the code. + +### Injectable Component Option + +This section briefly describes a possible implementation for +user-supplied services running within a node. This should not be +implemented unless user-supplied components are a hard requirement for +a user. + +In order to allow components to be replaced, a new public function +will be added to the public interface of `node` with a signature that +resembles the following: + +```go +func NewWithServices(conf *config.Config, + logger log.Logger, + cf proxy.ClientCreator, + gen *types.GenesisDoc, + srvs []service.Service, +) (service.Service, error) { +``` + +The `service.Service` objects will be initialized in the order supplied, after +all pre-configured/default services have started (and shut down in reverse +order). The given services may implement additional interfaces, allowing them +to replace specific default services. `NewWithServices` will validate input +service lists with the following rules: + +- None of the services may already be running. +- The caller may not supply more than one replacement reactor for a given + default service type. + +If callers violate any of these rules, `NewWithServices` will return +an error. To retract support for this kind of operation in the future, +the function can be modified to *always* return an error. + +## Consequences + +### Positive + +- The node package will become easier to maintain. + +- It will become easier to add additional services within tendermint + nodes. + +- It will become possible to replace default components in the node + package without vendoring the tendermint repo and modifying internal + code. + +- The current end-to-end (e2e) test suite will be able to prevent any + regressions, and the new functionality can be thoroughly unit tested. + +- The scope of this project is very narrow, which minimizes risk. + +### Negative + +- This increases our reliance on the `service.Service` interface which + is probably not an interface that we want to fully commit to. + +- This proposal implements a fairly minimal set of functionality and + leaves open the possibility for many additional features which are + not included in the scope of this proposal. + +### Neutral + +N/A + +## Open Questions + +- To what extent does this new initialization framework need to accommodate + the legacy p2p stack? Would it be possible to delay a great deal of this + work to the 0.36 cycle to avoid this complexity? + + - Answer: _depends on timing_, and the requirement to ship pluggable reactors in 0.35. + +- Where should additional public types be exported for the 0.35 + release? + + Related to the general project of API stabilization we want to deprecate + the `types` package, and move its contents into a new `pkg` hierarchy; + however, the design of the `pkg` interface is currently underspecified. + If `types` is going to remain for the 0.35 release, then we should consider + the impact of using multiple organizing modalities for this code within a + single release. + +## Future Work + +- Improve or simplify the `service.Service` interface. There are some + pretty clear limitations with this interface as written (there's no + way to timeout slow startup or shut down, the cycle between the + `service.BaseService` and `service.Service` implementations is + troubling, the default panic in `OnReset` seems troubling.) + +- As part of the refactor of `service.Service` have all services/nodes + respect the lifetime of a `context.Context` object, and avoid the + current practice of creating `context.Context` objects in p2p and + reactor code. This would be required for in-process multi-tenancy. + +- Support explicit dependencies between components and allow for + parallel startup, so that different reactors can startup at the same + time, where possible. + +## References + +- [this + branch](https://github.com/tendermint/tendermint/tree/tychoish/scratch-node-minimize) + contains experimental work in the implementation of the node package + to unwind some of the hard dependencies between components. + +- [the component + graph](https://peter.bourgon.org/go-for-industrial-programming/#the-component-graph) + as a framing for internal service construction. + +## Appendix + +### Dependencies + +There's a relationship between the blockchain and consensus reactor +described by the following dependency graph makes replacing some of +these components more difficult relative to other reactors or +components. + +![consensus blockchain dependency graph](./img/consensus_blockchain.png) diff --git a/docs/architecture/img/consensus_blockchain.png b/docs/architecture/img/consensus_blockchain.png new file mode 100644 index 0000000000000000000000000000000000000000..dd0f4daa83a3dd2e2d1490d7b3c26a77ebfe4d5d GIT binary patch literal 687838 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≫M?HPJVNYAHMb2hRMy> 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≫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
0K*h!lbw<@=MCZqOMv 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%0ARHVI&*dBKnfuvD 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� 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

Q-sPLcLEDq=LUd$do;k51Ejo%_yP% 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

Cd`*CJst9qNkR*iNrtt2Z0w)$fI#cB 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ℑdyCf%dkC71-FZJhzxgI4 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 z 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 literal 0 HcmV?d00001 From a6d20a6660b8c17bf66822c05bb7bc66490d03fe Mon Sep 17 00:00:00 2001 From: Sam Kleinman Date: Wed, 11 Aug 2021 11:37:05 -0400 Subject: [PATCH 33/35] pubsub: unsubscribe locking handling (#6816) --- libs/pubsub/pubsub.go | 46 +++++++++++++++++++++++++++---------------- 1 file changed, 29 insertions(+), 17 deletions(-) diff --git a/libs/pubsub/pubsub.go b/libs/pubsub/pubsub.go index 54a030fe8..7548470b5 100644 --- a/libs/pubsub/pubsub.go +++ b/libs/pubsub/pubsub.go @@ -231,34 +231,45 @@ func (s *Server) Unsubscribe(ctx context.Context, args UnsubscribeArgs) error { return err } var qs string + if args.Query != nil { qs = args.Query.String() } - s.mtx.RLock() - clientSubscriptions, ok := s.subscriptions[args.Subscriber] - if args.ID != "" { - qs, ok = clientSubscriptions[args.ID] + clientSubscriptions, err := func() (map[string]string, error) { + s.mtx.RLock() + defer s.mtx.RUnlock() - if ok && args.Query == nil { - var err error - args.Query, err = query.New(qs) - if err != nil { - return err + clientSubscriptions, ok := s.subscriptions[args.Subscriber] + if args.ID != "" { + qs, ok = clientSubscriptions[args.ID] + + if ok && args.Query == nil { + var err error + args.Query, err = query.New(qs) + if err != nil { + return nil, err + } } + } else if qs != "" { + args.ID, ok = clientSubscriptions[qs] } - } else if qs != "" { - args.ID, ok = clientSubscriptions[qs] - } - s.mtx.RUnlock() - if !ok { - return ErrSubscriptionNotFound + if !ok { + return nil, ErrSubscriptionNotFound + } + + return clientSubscriptions, nil + }() + + if err != nil { + return err } select { case s.cmds <- cmd{op: unsub, clientID: args.Subscriber, query: args.Query, subscription: &Subscription{id: args.ID}}: s.mtx.Lock() + defer s.mtx.Unlock() delete(clientSubscriptions, args.ID) delete(clientSubscriptions, qs) @@ -266,7 +277,6 @@ func (s *Server) Unsubscribe(ctx context.Context, args UnsubscribeArgs) error { if len(clientSubscriptions) == 0 { delete(s.subscriptions, args.Subscriber) } - s.mtx.Unlock() return nil case <-ctx.Done(): return ctx.Err() @@ -288,8 +298,10 @@ func (s *Server) UnsubscribeAll(ctx context.Context, clientID string) error { select { case s.cmds <- cmd{op: unsub, clientID: clientID}: s.mtx.Lock() + defer s.mtx.Unlock() + delete(s.subscriptions, clientID) - s.mtx.Unlock() + return nil case <-ctx.Done(): return ctx.Err() From cbfc04df6d48f6927f4eeec8727a1a45af98f353 Mon Sep 17 00:00:00 2001 From: Sam Kleinman Date: Wed, 11 Aug 2021 13:20:01 -0400 Subject: [PATCH 34/35] rpc: avoid panics in unsafe rpc calls with new p2p stack (#6817) --- rpc/core/net.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/rpc/core/net.go b/rpc/core/net.go index edcf8fffa..8f3e89d77 100644 --- a/rpc/core/net.go +++ b/rpc/core/net.go @@ -36,6 +36,10 @@ func (env *Environment) NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, e // UnsafeDialSeeds dials the given seeds (comma-separated id@IP:PORT). func (env *Environment) UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*ctypes.ResultDialSeeds, error) { + if env.P2PPeers == nil { + return nil, errors.New("peer management system does not support this operation") + } + if len(seeds) == 0 { return &ctypes.ResultDialSeeds{}, fmt.Errorf("%w: no seeds provided", ctypes.ErrInvalidRequest) } @@ -53,6 +57,10 @@ func (env *Environment) UnsafeDialPeers( peers []string, persistent, unconditional, private bool) (*ctypes.ResultDialPeers, error) { + if env.P2PPeers == nil { + return nil, errors.New("peer management system does not support this operation") + } + if len(peers) == 0 { return &ctypes.ResultDialPeers{}, fmt.Errorf("%w: no peers provided", ctypes.ErrInvalidRequest) } From d56a44b88476d4806478be66f83bbdf34d49dd4b Mon Sep 17 00:00:00 2001 From: Sam Kleinman Date: Thu, 12 Aug 2021 09:38:17 -0400 Subject: [PATCH 35/35] node: minimize hardcoded service initialization (#6798) * node: minimize hardcoded service initialization * hacking * nil safety * reduce space * remove genesis state store * fix lint * fix pex * unwind some odering effects * fix tests * remove unused experiment --- node/node.go | 270 ++++++++++++++------------------------ node/node_test.go | 82 +++++++----- node/setup.go | 2 +- rpc/client/local/local.go | 9 +- 4 files changed, 156 insertions(+), 207 deletions(-) diff --git a/node/node.go b/node/node.go index ced8af729..751c78889 100644 --- a/node/node.go +++ b/node/node.go @@ -18,7 +18,6 @@ import ( cfg "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto" cs "github.com/tendermint/tendermint/internal/consensus" - "github.com/tendermint/tendermint/internal/evidence" "github.com/tendermint/tendermint/internal/mempool" "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/internal/p2p/pex" @@ -37,7 +36,6 @@ import ( grpccore "github.com/tendermint/tendermint/rpc/grpc" rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server" sm "github.com/tendermint/tendermint/state" - "github.com/tendermint/tendermint/state/indexer" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" ) @@ -71,16 +69,12 @@ type nodeImpl struct { mempool mempool.Mempool stateSync bool // whether the node should state sync on startup stateSyncReactor *statesync.Reactor // for hosting and restoring state sync snapshots - consensusState *cs.State // latest consensus state consensusReactor *cs.Reactor // for participating in the consensus - pexReactor *pex.Reactor // for exchanging peer addresses - pexReactorV2 *pex.ReactorV2 // for exchanging peer addresses - evidenceReactor *evidence.Reactor - evidencePool *evidence.Pool // tracking evidence - proxyApp proxy.AppConns // connection to the application + pexReactor service.Service // for exchanging peer addresses + evidenceReactor service.Service rpcListeners []net.Listener // rpc servers - eventSinks []indexer.EventSink - indexerService *indexer.Service + indexerService service.Service + rpcEnv *rpccore.Environment prometheusSrv *http.Server } @@ -371,46 +365,43 @@ func makeNode(config *cfg.Config, // Note we currently use the addrBook regardless at least for AddOurAddress var ( - pexReactor *pex.Reactor - pexReactorV2 *pex.ReactorV2 - sw *p2p.Switch - addrBook pex.AddrBook + pexReactor service.Service + sw *p2p.Switch + addrBook pex.AddrBook ) pexCh := pex.ChannelDescriptor() transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh}) - if config.P2P.PexReactor { - if config.P2P.DisableLegacy { - addrBook = nil - pexReactorV2, err = createPEXReactorV2(config, logger, peerManager, router) - if err != nil { - return nil, err - } - } else { - // setup Transport and Switch - sw = createSwitch( - config, transport, p2pMetrics, mpReactorShim, bcReactorForSwitch, - stateSyncReactorShim, csReactorShim, evReactorShim, proxyApp, nodeInfo, nodeKey, p2pLogger, - ) - - err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) - if err != nil { - return nil, fmt.Errorf("could not add peers from persistent-peers field: %w", err) - } - - err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) - if err != nil { - return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) - } - - addrBook, err = createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) - if err != nil { - return nil, fmt.Errorf("could not create addrbook: %w", err) - } - - pexReactor = createPEXReactorAndAddToSwitch(addrBook, config, sw, logger) + if config.P2P.DisableLegacy { + addrBook = nil + pexReactor, err = createPEXReactorV2(config, logger, peerManager, router) + if err != nil { + return nil, err } + } else { + // setup Transport and Switch + sw = createSwitch( + config, transport, p2pMetrics, mpReactorShim, bcReactorForSwitch, + stateSyncReactorShim, csReactorShim, evReactorShim, proxyApp, nodeInfo, nodeKey, p2pLogger, + ) + + err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) + if err != nil { + return nil, fmt.Errorf("could not add peers from persistent-peers field: %w", err) + } + + err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) + if err != nil { + return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) + } + + addrBook, err = createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) + if err != nil { + return nil, fmt.Errorf("could not create addrbook: %w", err) + } + + pexReactor = createPEXReactorAndAddToSwitch(addrBook, config, sw, logger) } if config.RPC.PprofListenAddress != "" { @@ -438,19 +429,37 @@ func makeNode(config *cfg.Config, bcReactor: bcReactor, mempoolReactor: mpReactor, mempool: mp, - consensusState: csState, consensusReactor: csReactor, stateSyncReactor: stateSyncReactor, stateSync: stateSync, pexReactor: pexReactor, - pexReactorV2: pexReactorV2, evidenceReactor: evReactor, - evidencePool: evPool, - proxyApp: proxyApp, indexerService: indexerService, eventBus: eventBus, - eventSinks: eventSinks, + + rpcEnv: &rpccore.Environment{ + ProxyAppQuery: proxyApp.Query(), + ProxyAppMempool: proxyApp.Mempool(), + + StateStore: stateStore, + BlockStore: blockStore, + EvidencePool: evPool, + ConsensusState: csState, + P2PPeers: sw, + BlockSyncReactor: bcReactor.(cs.BlockSyncReactor), + + GenDoc: genDoc, + EventSinks: eventSinks, + ConsensusReactor: csReactor, + EventBus: eventBus, + Mempool: mp, + Logger: logger.With("module", "rpc"), + Config: *config.RPC, + }, } + + node.rpcEnv.P2PTransport = node + node.BaseService = *service.NewBaseService(logger, "Node", node) return node, nil @@ -483,25 +492,6 @@ func makeSeedNode(config *cfg.Config, p2pMetrics := p2p.PrometheusMetrics(config.Instrumentation.Namespace, "chain_id", genDoc.ChainID) p2pLogger := logger.With("module", "p2p") transport := createTransport(p2pLogger, config) - sw := createSwitch( - config, transport, p2pMetrics, nil, nil, - nil, nil, nil, nil, nodeInfo, nodeKey, p2pLogger, - ) - - err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) - if err != nil { - return nil, fmt.Errorf("could not add peers from persistent_peers field: %w", err) - } - - err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) - if err != nil { - return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) - } - - addrBook, err := createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) - if err != nil { - return nil, fmt.Errorf("could not create addrbook: %w", err) - } peerManager, err := createPeerManager(config, dbProvider, p2pLogger, nodeKey.ID) if err != nil { @@ -515,8 +505,9 @@ func makeSeedNode(config *cfg.Config, } var ( - pexReactor *pex.Reactor - pexReactorV2 *pex.ReactorV2 + pexReactor service.Service + sw *p2p.Switch + addrBook pex.AddrBook ) // add the pex reactor @@ -526,11 +517,31 @@ func makeSeedNode(config *cfg.Config, pexCh := pex.ChannelDescriptor() transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh}) if config.P2P.DisableLegacy { - pexReactorV2, err = createPEXReactorV2(config, logger, peerManager, router) + pexReactor, err = createPEXReactorV2(config, logger, peerManager, router) if err != nil { return nil, err } } else { + sw = createSwitch( + config, transport, p2pMetrics, nil, nil, + nil, nil, nil, nil, nodeInfo, nodeKey, p2pLogger, + ) + + err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) + if err != nil { + return nil, fmt.Errorf("could not add peers from persistent_peers field: %w", err) + } + + err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) + if err != nil { + return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) + } + + addrBook, err = createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) + if err != nil { + return nil, fmt.Errorf("could not create addrbook: %w", err) + } + pexReactor = createPEXReactorAndAddToSwitch(addrBook, config, sw, logger) } @@ -553,8 +564,7 @@ func makeSeedNode(config *cfg.Config, peerManager: peerManager, router: router, - pexReactor: pexReactor, - pexReactorV2: pexReactorV2, + pexReactor: pexReactor, } node.BaseService = *service.NewBaseService(logger, "SeedNode", node) @@ -595,23 +605,22 @@ func (n *nodeImpl) OnStart() error { } n.isListening = true - n.Logger.Info("p2p service", "legacy_enabled", !n.config.P2P.DisableLegacy) if n.config.P2P.DisableLegacy { - err = n.router.Start() + if err = n.router.Start(); err != nil { + return err + } } else { // Add private IDs to addrbook to block those peers being added n.addrBook.AddPrivateIDs(strings.SplitAndTrimEmpty(n.config.P2P.PrivatePeerIDs, ",", " ")) - err = n.sw.Start() - } - if err != nil { - return err + if err = n.sw.Start(); err != nil { + return err + } } if n.config.Mode != cfg.ModeSeed { if n.config.BlockSync.Version == cfg.BlockSyncV0 { - // Start the real blockchain reactor separately since the switch uses the shim. if err := n.bcReactor.Start(); err != nil { return err } @@ -638,8 +647,8 @@ func (n *nodeImpl) OnStart() error { } } - if n.config.P2P.DisableLegacy && n.pexReactorV2 != nil { - if err := n.pexReactorV2.Start(); err != nil { + if n.config.P2P.DisableLegacy { + if err := n.pexReactor.Start(); err != nil { return err } } else { @@ -648,7 +657,6 @@ func (n *nodeImpl) OnStart() error { if err != nil { return fmt.Errorf("could not dial peers from persistent-peers field: %w", err) } - } // Run state sync @@ -723,10 +731,8 @@ func (n *nodeImpl) OnStop() { } } - if n.config.P2P.DisableLegacy && n.pexReactorV2 != nil { - if err := n.pexReactorV2.Stop(); err != nil { - n.Logger.Error("failed to stop the PEX v2 reactor", "err", err) - } + if err := n.pexReactor.Stop(); err != nil { + n.Logger.Error("failed to stop the PEX v2 reactor", "err", err) } if n.config.P2P.DisableLegacy { @@ -767,55 +773,23 @@ func (n *nodeImpl) OnStop() { } } -// ConfigureRPC makes sure RPC has all the objects it needs to operate. -func (n *nodeImpl) ConfigureRPC() (*rpccore.Environment, error) { - rpcCoreEnv := rpccore.Environment{ - ProxyAppQuery: n.proxyApp.Query(), - ProxyAppMempool: n.proxyApp.Mempool(), - - StateStore: n.stateStore, - BlockStore: n.blockStore, - EvidencePool: n.evidencePool, - ConsensusState: n.consensusState, - P2PPeers: n.sw, - P2PTransport: n, - - GenDoc: n.genesisDoc, - EventSinks: n.eventSinks, - ConsensusReactor: n.consensusReactor, - EventBus: n.eventBus, - Mempool: n.mempool, - - Logger: n.Logger.With("module", "rpc"), - - Config: *n.config.RPC, - BlockSyncReactor: n.bcReactor.(cs.BlockSyncReactor), - } +func (n *nodeImpl) startRPC() ([]net.Listener, error) { if n.config.Mode == cfg.ModeValidator { pubKey, err := n.privValidator.GetPubKey(context.TODO()) if pubKey == nil || err != nil { return nil, fmt.Errorf("can't get pubkey: %w", err) } - rpcCoreEnv.PubKey = pubKey + n.rpcEnv.PubKey = pubKey } - if err := rpcCoreEnv.InitGenesisChunks(); err != nil { - return nil, err - } - - return &rpcCoreEnv, nil -} - -func (n *nodeImpl) startRPC() ([]net.Listener, error) { - env, err := n.ConfigureRPC() - if err != nil { + if err := n.rpcEnv.InitGenesisChunks(); err != nil { return nil, err } listenAddrs := strings.SplitAndTrimEmpty(n.config.RPC.ListenAddress, ",", " ") - routes := env.GetRoutes() + routes := n.rpcEnv.GetRoutes() if n.config.RPC.Unsafe { - env.AddUnsafe(routes) + n.rpcEnv.AddUnsafe(routes) } config := rpcserver.DefaultConfig() @@ -912,7 +886,7 @@ func (n *nodeImpl) startRPC() ([]net.Listener, error) { return nil, err } go func() { - if err := grpccore.StartGRPCServer(env, listener); err != nil { + if err := grpccore.StartGRPCServer(n.rpcEnv, listener); err != nil { n.Logger.Error("Error starting gRPC server", "err", err) } }() @@ -945,46 +919,16 @@ func (n *nodeImpl) startPrometheusServer(addr string) *http.Server { return srv } -// Switch returns the Node's Switch. -func (n *nodeImpl) Switch() *p2p.Switch { - return n.sw -} - -// BlockStore returns the Node's BlockStore. -func (n *nodeImpl) BlockStore() *store.BlockStore { - return n.blockStore -} - -// ConsensusState returns the Node's ConsensusState. -func (n *nodeImpl) ConsensusState() *cs.State { - return n.consensusState -} - // ConsensusReactor returns the Node's ConsensusReactor. func (n *nodeImpl) ConsensusReactor() *cs.Reactor { return n.consensusReactor } -// MempoolReactor returns the Node's mempool reactor. -func (n *nodeImpl) MempoolReactor() service.Service { - return n.mempoolReactor -} - // Mempool returns the Node's mempool. func (n *nodeImpl) Mempool() mempool.Mempool { return n.mempool } -// PEXReactor returns the Node's PEXReactor. It returns nil if PEX is disabled. -func (n *nodeImpl) PEXReactor() *pex.Reactor { - return n.pexReactor -} - -// EvidencePool returns the Node's EvidencePool. -func (n *nodeImpl) EvidencePool() *evidence.Pool { - return n.evidencePool -} - // EventBus returns the Node's EventBus. func (n *nodeImpl) EventBus() *types.EventBus { return n.eventBus @@ -1001,19 +945,9 @@ func (n *nodeImpl) GenesisDoc() *types.GenesisDoc { return n.genesisDoc } -// ProxyApp returns the Node's AppConns, representing its connections to the ABCI application. -func (n *nodeImpl) ProxyApp() proxy.AppConns { - return n.proxyApp -} - -// Config returns the Node's config. -func (n *nodeImpl) Config() *cfg.Config { - return n.config -} - -// EventSinks returns the Node's event indexing sinks. -func (n *nodeImpl) EventSinks() []indexer.EventSink { - return n.eventSinks +// RPCEnvironment makes sure RPC has all the objects it needs to operate. +func (n *nodeImpl) RPCEnvironment() *rpccore.Environment { + return n.rpcEnv } //------------------------------------------------------------------------------ diff --git a/node/node_test.go b/node/node_test.go index 16edb4210..64b28c0bb 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -513,36 +513,50 @@ func TestNodeSetEventSink(t *testing.T) { config := cfg.ResetTestRoot("node_app_version_test") defer os.RemoveAll(config.RootDir) - n := getTestNode(t, config, log.TestingLogger()) + logger := log.TestingLogger() + setupTest := func(t *testing.T, conf *cfg.Config) []indexer.EventSink { + eventBus, err := createAndStartEventBus(logger) + require.NoError(t, err) - assert.Equal(t, 1, len(n.eventSinks)) - assert.Equal(t, indexer.KV, n.eventSinks[0].Type()) + genDoc, err := types.GenesisDocFromFile(config.GenesisFile()) + require.NoError(t, err) + + indexService, eventSinks, err := createAndStartIndexerService(config, + cfg.DefaultDBProvider, eventBus, logger, genDoc.ChainID) + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, indexService.Stop()) }) + return eventSinks + } + + eventSinks := setupTest(t, config) + assert.Equal(t, 1, len(eventSinks)) + assert.Equal(t, indexer.KV, eventSinks[0].Type()) config.TxIndex.Indexer = []string{"null"} - n = getTestNode(t, config, log.TestingLogger()) + eventSinks = setupTest(t, config) - assert.Equal(t, 1, len(n.eventSinks)) - assert.Equal(t, indexer.NULL, n.eventSinks[0].Type()) + assert.Equal(t, 1, len(eventSinks)) + assert.Equal(t, indexer.NULL, eventSinks[0].Type()) config.TxIndex.Indexer = []string{"null", "kv"} - n = getTestNode(t, config, log.TestingLogger()) + eventSinks = setupTest(t, config) - assert.Equal(t, 1, len(n.eventSinks)) - assert.Equal(t, indexer.NULL, n.eventSinks[0].Type()) + assert.Equal(t, 1, len(eventSinks)) + assert.Equal(t, indexer.NULL, eventSinks[0].Type()) config.TxIndex.Indexer = []string{"kvv"} - ns, err := newDefaultNode(config, log.TestingLogger()) + ns, err := newDefaultNode(config, logger) assert.Nil(t, ns) assert.Equal(t, errors.New("unsupported event sink type"), err) config.TxIndex.Indexer = []string{} - n = getTestNode(t, config, log.TestingLogger()) + eventSinks = setupTest(t, config) - assert.Equal(t, 1, len(n.eventSinks)) - assert.Equal(t, indexer.NULL, n.eventSinks[0].Type()) + assert.Equal(t, 1, len(eventSinks)) + assert.Equal(t, indexer.NULL, eventSinks[0].Type()) config.TxIndex.Indexer = []string{"psql"} - ns, err = newDefaultNode(config, log.TestingLogger()) + ns, err = newDefaultNode(config, logger) assert.Nil(t, ns) assert.Equal(t, errors.New("the psql connection settings cannot be empty"), err) @@ -550,46 +564,46 @@ func TestNodeSetEventSink(t *testing.T) { config.TxIndex.Indexer = []string{"psql"} config.TxIndex.PsqlConn = psqlConn - n = getTestNode(t, config, log.TestingLogger()) - assert.Equal(t, 1, len(n.eventSinks)) - assert.Equal(t, indexer.PSQL, n.eventSinks[0].Type()) - n.OnStop() + eventSinks = setupTest(t, config) + + assert.Equal(t, 1, len(eventSinks)) + assert.Equal(t, indexer.PSQL, eventSinks[0].Type()) config.TxIndex.Indexer = []string{"psql", "kv"} config.TxIndex.PsqlConn = psqlConn - n = getTestNode(t, config, log.TestingLogger()) - assert.Equal(t, 2, len(n.eventSinks)) + eventSinks = setupTest(t, config) + + assert.Equal(t, 2, len(eventSinks)) // we use map to filter the duplicated sinks, so it's not guarantee the order when append sinks. - if n.eventSinks[0].Type() == indexer.KV { - assert.Equal(t, indexer.PSQL, n.eventSinks[1].Type()) + if eventSinks[0].Type() == indexer.KV { + assert.Equal(t, indexer.PSQL, eventSinks[1].Type()) } else { - assert.Equal(t, indexer.PSQL, n.eventSinks[0].Type()) - assert.Equal(t, indexer.KV, n.eventSinks[1].Type()) + assert.Equal(t, indexer.PSQL, eventSinks[0].Type()) + assert.Equal(t, indexer.KV, eventSinks[1].Type()) } - n.OnStop() config.TxIndex.Indexer = []string{"kv", "psql"} config.TxIndex.PsqlConn = psqlConn - n = getTestNode(t, config, log.TestingLogger()) - assert.Equal(t, 2, len(n.eventSinks)) - if n.eventSinks[0].Type() == indexer.KV { - assert.Equal(t, indexer.PSQL, n.eventSinks[1].Type()) + eventSinks = setupTest(t, config) + + assert.Equal(t, 2, len(eventSinks)) + if eventSinks[0].Type() == indexer.KV { + assert.Equal(t, indexer.PSQL, eventSinks[1].Type()) } else { - assert.Equal(t, indexer.PSQL, n.eventSinks[0].Type()) - assert.Equal(t, indexer.KV, n.eventSinks[1].Type()) + assert.Equal(t, indexer.PSQL, eventSinks[0].Type()) + assert.Equal(t, indexer.KV, eventSinks[1].Type()) } - n.OnStop() var e = errors.New("found duplicated sinks, please check the tx-index section in the config.toml") config.TxIndex.Indexer = []string{"psql", "kv", "Kv"} config.TxIndex.PsqlConn = psqlConn - _, err = newDefaultNode(config, log.TestingLogger()) + _, err = newDefaultNode(config, logger) require.Error(t, err) assert.Equal(t, e, err) config.TxIndex.Indexer = []string{"Psql", "kV", "kv", "pSql"} config.TxIndex.PsqlConn = psqlConn - _, err = newDefaultNode(config, log.TestingLogger()) + _, err = newDefaultNode(config, logger) require.Error(t, err) assert.Equal(t, e, err) } diff --git a/node/setup.go b/node/setup.go index af48fb382..ceadcd688 100644 --- a/node/setup.go +++ b/node/setup.go @@ -700,7 +700,7 @@ func createPEXReactorV2( logger log.Logger, peerManager *p2p.PeerManager, router *p2p.Router, -) (*pex.ReactorV2, error) { +) (service.Service, error) { channel, err := router.OpenChannel(pex.ChannelDescriptor(), &protop2p.PexMessage{}, 128) if err != nil { diff --git a/rpc/client/local/local.go b/rpc/client/local/local.go index 0663ebf67..d752e6a93 100644 --- a/rpc/client/local/local.go +++ b/rpc/client/local/local.go @@ -2,6 +2,7 @@ package local import ( "context" + "errors" "fmt" "time" @@ -46,15 +47,15 @@ type Local struct { // NodeService describes the portion of the node interface that the // local RPC client constructor needs to build a local client. type NodeService interface { - ConfigureRPC() (*rpccore.Environment, error) + RPCEnvironment() *rpccore.Environment EventBus() *types.EventBus } // New configures a client that calls the Node directly. func New(node NodeService) (*Local, error) { - env, err := node.ConfigureRPC() - if err != nil { - return nil, err + env := node.RPCEnvironment() + if env == nil { + return nil, errors.New("rpc is nil") } return &Local{ EventBus: node.EventBus(),