mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-03-27 12:05:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin' into jasmina/4457-blocksync-verification_part1

Browse Source
This commit is contained in:
Jasmina Malicevic
2022-06-15 15:43:46 +02:00
parent 5c026478b9 1062ae73d6
commit eef71a84aa
8 changed files with 115 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/e2e-nightly-36x.yml vendored
View File

@@ -15,7 +15,7 @@ jobs:
strategy:
fail-fast: false
matrix:
group: ['00', '01', '02', '03']
group: ['00', '01', '02', '03', '04']
runs-on: ubuntu-latest
timeout-minutes: 60
steps:
@@ -35,7 +35,7 @@ jobs:
- name: Generate testnets
working-directory: test/e2e
# When changing -g, also change the matrix groups above
run: ./build/generator -g 4 -d networks/nightly
run: ./build/generator -g 5 -d networks/nightly
- name: Run testnets in group ${{ matrix.group }}
working-directory: test/e2e

2
go.mod
View File

@@ -42,7 +42,7 @@ require (
github.com/creachadair/taskgroup v0.3.2
github.com/golangci/golangci-lint v1.46.0
github.com/google/go-cmp v0.5.8
github.com/vektra/mockery/v2 v2.13.0
github.com/vektra/mockery/v2 v2.13.1
gotest.tools v2.2.0+incompatible
)

4
go.sum
View File

@@ -1116,8 +1116,8 @@ github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyC
github.com/valyala/fasthttp v1.30.0/go.mod h1:2rsYD01CKFrjjsvFxx75KlEUNpWNBY9JWD3K/7o2Cus=
github.com/valyala/quicktemplate v1.7.0/go.mod h1:sqKJnoaOF88V07vkO+9FL8fb9uZg/VPSJnLYn+LmLk8=
github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
github.com/vektra/mockery/v2 v2.13.0 h1:jzHQuiWMbLK52usAz/3wyIf07gZnACOsTJ8/AcHA/2s=
github.com/vektra/mockery/v2 v2.13.0/go.mod h1:bnD1T8tExSgPD1ripLkDbr60JA9VtQeu12P3wgLZd7M=
github.com/vektra/mockery/v2 v2.13.1 h1:Lqs7aZiC7TwZO76fJ/4Zsb3NaO4F7cuuz0mZLYeNwtQ=
github.com/vektra/mockery/v2 v2.13.1/go.mod h1:bnD1T8tExSgPD1ripLkDbr60JA9VtQeu12P3wgLZd7M=
github.com/viki-org/dnscache v0.0.0-20130720023526-c70c1f23c5d8/go.mod h1:dniwbG03GafCjFohMDmz6Zc6oCuiqgH6tGNyXTkHzXE=
github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=

17
internal/p2p/router.go
View File

@@ -470,14 +470,17 @@ func (r *Router) dialSleep(ctx context.Context) {
func (r *Router) acceptPeers(ctx context.Context, transport Transport) {
for {
conn, err := transport.Accept(ctx)
switch err {
case nil:
case io.EOF:
r.logger.Debug("stopping accept routine", "transport", transport)
switch {
case errors.Is(err, context.Canceled), errors.Is(err, context.DeadlineExceeded):
r.logger.Debug("stopping accept routine", "transport", transport, "err", "context canceled")
return
default:
case errors.Is(err, io.EOF):
r.logger.Debug("stopping accept routine", "transport", transport, "err", "EOF")
return
case err != nil:
// in this case we got an error from the net.Listener.
r.logger.Error("failed to accept connection", "transport", transport, "err", err)
return
continue
}
incomingIP := conn.RemoteEndpoint().IP
@@ -489,7 +492,7 @@ func (r *Router) acceptPeers(ctx context.Context, transport Transport) {
"close_err", closeErr,
)
return
continue
}
// Spawn a goroutine for the handshake, to avoid head-of-line blocking.

96
internal/p2p/router_test.go
View File

@@ -442,78 +442,48 @@ func TestRouter_AcceptPeers(t *testing.T) {
}
}
func TestRouter_AcceptPeers_Error(t *testing.T) {
t.Cleanup(leaktest.Check(t))
func TestRouter_AcceptPeers_Errors(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
for _, err := range []error{io.EOF, context.Canceled, context.DeadlineExceeded} {
t.Run(err.Error(), func(t *testing.T) {
t.Cleanup(leaktest.Check(t))
// Set up a mock transport that returns an error, which should prevent
// the router from calling Accept again.
mockTransport := &mocks.Transport{}
mockTransport.On("String").Maybe().Return("mock")
mockTransport.On("Accept", mock.Anything).Once().Return(nil, errors.New("boom"))
mockTransport.On("Close").Return(nil)
mockTransport.On("Listen", mock.Anything).Return(nil)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Set up and start the router.
peerManager, err := p2p.NewPeerManager(selfID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
require.NoError(t, err)
// Set up a mock transport that returns io.EOF once, which should prevent
// the router from calling Accept again.
mockTransport := &mocks.Transport{}
mockTransport.On("String").Maybe().Return("mock")
mockTransport.On("Accept", mock.Anything).Once().Return(nil, err)
mockTransport.On("Close").Return(nil)
mockTransport.On("Listen", mock.Anything).Return(nil)
router, err := p2p.NewRouter(
log.NewNopLogger(),
p2p.NopMetrics(),
selfKey,
peerManager,
func() *types.NodeInfo { return &selfInfo },
mockTransport,
nil,
p2p.RouterOptions{},
)
require.NoError(t, err)
// Set up and start the router.
peerManager, err := p2p.NewPeerManager(selfID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
require.NoError(t, err)
require.NoError(t, router.Start(ctx))
time.Sleep(time.Second)
router.Stop()
router, err := p2p.NewRouter(
log.NewNopLogger(),
p2p.NopMetrics(),
selfKey,
peerManager,
func() *types.NodeInfo { return &selfInfo },
mockTransport,
nil,
p2p.RouterOptions{},
)
require.NoError(t, err)
mockTransport.AssertExpectations(t)
}
require.NoError(t, router.Start(ctx))
time.Sleep(time.Second)
router.Stop()
func TestRouter_AcceptPeers_ErrorEOF(t *testing.T) {
t.Cleanup(leaktest.Check(t))
mockTransport.AssertExpectations(t)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
})
// Set up a mock transport that returns io.EOF once, which should prevent
// the router from calling Accept again.
mockTransport := &mocks.Transport{}
mockTransport.On("String").Maybe().Return("mock")
mockTransport.On("Accept", mock.Anything).Once().Return(nil, io.EOF)
mockTransport.On("Close").Return(nil)
mockTransport.On("Listen", mock.Anything).Return(nil)
// Set up and start the router.
peerManager, err := p2p.NewPeerManager(selfID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
require.NoError(t, err)
router, err := p2p.NewRouter(
log.NewNopLogger(),
p2p.NopMetrics(),
selfKey,
peerManager,
func() *types.NodeInfo { return &selfInfo },
mockTransport,
nil,
p2p.RouterOptions{},
)
require.NoError(t, err)
require.NoError(t, router.Start(ctx))
time.Sleep(time.Second)
router.Stop()
mockTransport.AssertExpectations(t)
}
}
func TestRouter_AcceptPeers_HeadOfLineBlocking(t *testing.T) {

19
types/vote.go
View File

@@ -13,7 +13,8 @@ import (
)
const (
nilVoteStr string = "nil-Vote"
absentVoteStr string = "Vote{absent}"
nilVoteStr string = "nil"
// The maximum supported number of bytes in a vote extension.
MaxVoteExtensionSize int = 1024 * 1024
@@ -189,7 +190,7 @@ func (vote *Vote) Copy() *Vote {
// 10. timestamp
func (vote *Vote) String() string {
if vote == nil {
return nilVoteStr
return absentVoteStr
}
var typeString string
@@ -202,16 +203,22 @@ func (vote *Vote) String() string {
panic("Unknown vote type")
}
return fmt.Sprintf("Vote{%v:%X %v/%02d/%v(%v) %X %X %X @ %s}",
var blockHashString string
if len(vote.BlockID.Hash) > 0 {
blockHashString = fmt.Sprintf("%X", tmbytes.Fingerprint(vote.BlockID.Hash))
} else {
blockHashString = nilVoteStr
}
return fmt.Sprintf("Vote{%v:%X %v/%d %s %s %X %d @ %s}",
vote.ValidatorIndex,
tmbytes.Fingerprint(vote.ValidatorAddress),
vote.Height,
vote.Round,
vote.Type,
typeString,
tmbytes.Fingerprint(vote.BlockID.Hash),
blockHashString,
tmbytes.Fingerprint(vote.Signature),
tmbytes.Fingerprint(vote.Extension),
len(vote.Extension),
CanonicalTime(vote.Timestamp),
)
}

4
types/vote_set.go
View File

@@ -505,7 +505,7 @@ func (voteSet *VoteSet) StringIndented(indent string) string {
voteStrings := make([]string, len(voteSet.votes))
for i, vote := range voteSet.votes {
if vote == nil {
voteStrings[i] = nilVoteStr
voteStrings[i] = absentVoteStr
} else {
voteStrings[i] = vote.String()
}
@@ -570,7 +570,7 @@ func (voteSet *VoteSet) voteStrings() []string {
voteStrings := make([]string, len(voteSet.votes))
for i, vote := range voteSet.votes {
if vote == nil {
voteStrings[i] = nilVoteStr
voteStrings[i] = absentVoteStr
} else {
voteStrings[i] = vote.String()
}

60
types/vote_test.go
View File

@@ -2,6 +2,7 @@ package types
import (
"context"
"fmt"
"testing"
"time"
@@ -16,6 +17,22 @@ import (
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
)
const (
//nolint: lll
preCommitTestStr = `Vote{56789:6AF1F4111082 12345/2 Precommit 8B01023386C3 000000000000 0 @ 2017-12-25T03:00:01.234Z}`
//nolint: lll
preVoteTestStr = `Vote{56789:6AF1F4111082 12345/2 Prevote 8B01023386C3 000000000000 0 @ 2017-12-25T03:00:01.234Z}`
)
var (
// nolint: lll
nilVoteTestStr = fmt.Sprintf(`Vote{56789:6AF1F4111082 12345/2 Precommit %s 000000000000 0 @ 2017-12-25T03:00:01.234Z}`, nilVoteStr)
formatNonEmptyVoteExtensionFn = func(voteExtensionLength int) string {
// nolint: lll
return fmt.Sprintf(`Vote{56789:6AF1F4111082 12345/2 Precommit 8B01023386C3 000000000000 %d @ 2017-12-25T03:00:01.234Z}`, voteExtensionLength)
}
)
func examplePrevote(t *testing.T) *Vote {
t.Helper()
return exampleVote(t, byte(tmproto.PrevoteType))
@@ -321,16 +338,43 @@ func TestVoteVerify(t *testing.T) {
}
func TestVoteString(t *testing.T) {
str := examplePrecommit(t).String()
expected := `Vote{56789:6AF1F4111082 12345/02/SIGNED_MSG_TYPE_PRECOMMIT(Precommit) 8B01023386C3 000000000000 000000000000 @ 2017-12-25T03:00:01.234Z}` //nolint:lll //ignore line length for tests
if str != expected {
t.Errorf("got unexpected string for Vote. Expected:\n%v\nGot:\n%v", expected, str)
testcases := map[string]struct {
vote *Vote
expectedResult string
}{
"pre-commit": {
vote: examplePrecommit(t),
expectedResult: preCommitTestStr,
},
"pre-vote": {
vote: examplePrevote(t),
expectedResult: preVoteTestStr,
},
"absent vote": {
expectedResult: absentVoteStr,
},
"nil vote": {
vote: func() *Vote {
v := examplePrecommit(t)
v.BlockID.Hash = nil
return v
}(),
expectedResult: nilVoteTestStr,
},
"non-empty vote extension": {
vote: func() *Vote {
v := examplePrecommit(t)
v.Extension = []byte{1, 2}
return v
}(),
expectedResult: formatNonEmptyVoteExtensionFn(2),
},
}
str2 := examplePrevote(t).String()
expected = `Vote{56789:6AF1F4111082 12345/02/SIGNED_MSG_TYPE_PREVOTE(Prevote) 8B01023386C3 000000000000 000000000000 @ 2017-12-25T03:00:01.234Z}` //nolint:lll //ignore line length for tests
if str2 != expected {
t.Errorf("got unexpected string for Vote. Expected:\n%v\nGot:\n%v", expected, str2)
for name, tc := range testcases {
t.Run(name, func(t *testing.T) {
require.Equal(t, tc.expectedResult, tc.vote.String())
})
}
}