9b364aa7ee
The problem is in peer disconnection due to invalid GetBlockByIndex
payload (the logs are from some patched neo-go version):
```
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.490Z INFO new peer connected {"addr": "10.78.69.115:50846", "peerCount": 3}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.490Z WARN peer disconnected {"addr": "10.78.69.115:50846", "error": "invalid block count", "peerCount": 2}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.490Z INFO started protocol {"addr": "10.78.69.115:50846", "userAgent": "/NEO-GO:1.0.0/", "startHeight": 0, "id": 1339571820}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.491Z INFO new peer connected {"addr": "10.78.69.115:50856", "peerCount": 3}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.492Z WARN peer disconnected {"addr": "10.78.69.115:50856", "error": "invalid block count", "peerCount": 2}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.492Z INFO started protocol {"addr": "10.78.69.115:50856", "userAgent": "/NEO-GO:1.0.0/", "startHeight": 0, "id": 1339571820}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.492Z INFO new peer connected {"addr": "10.78.69.115:50858", "peerCount": 3}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.493Z INFO started protocol {"addr": "10.78.69.115:50858", "userAgent": "/NEO-GO:1.0.0/", "startHeight": 0, "id": 1339571820}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.493Z WARN peer disconnected {"addr": "10.78.69.115:50858", "error": "invalid block count", "peerCount": 2}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.494Z INFO new peer connected {"addr": "10.78.69.115:50874", "peerCount": 3}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.494Z INFO started protocol {"addr": "10.78.69.115:50874", "userAgent": "/NEO-GO:1.0.0/", "startHeight": 0, "id": 1339571820}
дек 15 16:02:39 glagoli neo-go[928530]: 2022-12-15T16:02:39.494Z WARN peer disconnected {"addr": "10.78.69.115:50874", "error": "invalid block count", "peerCount": 2}
```
GetBlockByIndex payload can't be decoded, and the only possible cause
is zero (or <-1, but it's probably not the case) block count requested.
Error is improved as far.
90 lines
3.2 KiB
Go
90 lines
3.2 KiB
Go
package network
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/nspcc-dev/neo-go/internal/fakechain"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/block"
|
|
"github.com/stretchr/testify/assert"
|
|
"go.uber.org/zap/zaptest"
|
|
)
|
|
|
|
func TestBlockQueue(t *testing.T) {
|
|
chain := fakechain.NewFakeChain()
|
|
// notice, it's not yet running
|
|
bq := newBlockQueue(0, chain, zaptest.NewLogger(t), nil)
|
|
blocks := make([]*block.Block, 11)
|
|
for i := 1; i < 11; i++ {
|
|
blocks[i] = &block.Block{Header: block.Header{Index: uint32(i)}}
|
|
}
|
|
// not the ones expected currently
|
|
for i := 3; i < 5; i++ {
|
|
assert.NoError(t, bq.putBlock(blocks[i]))
|
|
}
|
|
last, capLeft := bq.lastQueued()
|
|
assert.Equal(t, uint32(0), last)
|
|
assert.Equal(t, blockCacheSize-2, capLeft)
|
|
// nothing should be put into the blockchain
|
|
assert.Equal(t, uint32(0), chain.BlockHeight())
|
|
assert.Equal(t, 2, bq.length())
|
|
// now added the expected ones (with duplicates)
|
|
for i := 1; i < 5; i++ {
|
|
assert.NoError(t, bq.putBlock(blocks[i]))
|
|
}
|
|
// but they're still not put into the blockchain, because bq isn't running
|
|
last, capLeft = bq.lastQueued()
|
|
assert.Equal(t, uint32(4), last)
|
|
assert.Equal(t, blockCacheSize-4, capLeft)
|
|
assert.Equal(t, uint32(0), chain.BlockHeight())
|
|
assert.Equal(t, 4, bq.length())
|
|
// block with too big index is dropped
|
|
assert.NoError(t, bq.putBlock(&block.Block{Header: block.Header{Index: bq.chain.BlockHeight() + blockCacheSize + 1}}))
|
|
assert.Equal(t, 4, bq.length())
|
|
go bq.run()
|
|
// run() is asynchronous, so we need some kind of timeout anyway and this is the simplest one
|
|
assert.Eventually(t, func() bool { return chain.BlockHeight() == 4 }, 4*time.Second, 100*time.Millisecond)
|
|
last, capLeft = bq.lastQueued()
|
|
assert.Equal(t, uint32(4), last)
|
|
assert.Equal(t, blockCacheSize, capLeft)
|
|
assert.Equal(t, 0, bq.length())
|
|
assert.Equal(t, uint32(4), chain.BlockHeight())
|
|
// put some old blocks
|
|
for i := 1; i < 5; i++ {
|
|
assert.NoError(t, bq.putBlock(blocks[i]))
|
|
}
|
|
last, capLeft = bq.lastQueued()
|
|
assert.Equal(t, uint32(4), last)
|
|
assert.Equal(t, blockCacheSize, capLeft)
|
|
assert.Equal(t, 0, bq.length())
|
|
assert.Equal(t, uint32(4), chain.BlockHeight())
|
|
// unexpected blocks with run() active
|
|
assert.NoError(t, bq.putBlock(blocks[8]))
|
|
assert.Equal(t, 1, bq.length())
|
|
assert.Equal(t, uint32(4), chain.BlockHeight())
|
|
assert.NoError(t, bq.putBlock(blocks[7]))
|
|
assert.Equal(t, 2, bq.length())
|
|
assert.Equal(t, uint32(4), chain.BlockHeight())
|
|
// sparse put
|
|
assert.NoError(t, bq.putBlock(blocks[10]))
|
|
assert.Equal(t, 3, bq.length())
|
|
assert.Equal(t, uint32(4), chain.BlockHeight())
|
|
assert.NoError(t, bq.putBlock(blocks[6]))
|
|
assert.NoError(t, bq.putBlock(blocks[5]))
|
|
// run() is asynchronous, so we need some kind of timeout anyway and this is the simplest one
|
|
assert.Eventually(t, func() bool { return chain.BlockHeight() == 8 }, 4*time.Second, 100*time.Millisecond)
|
|
last, capLeft = bq.lastQueued()
|
|
assert.Equal(t, uint32(8), last)
|
|
assert.Equal(t, blockCacheSize-1, capLeft)
|
|
assert.Equal(t, 1, bq.length())
|
|
assert.Equal(t, uint32(8), chain.BlockHeight())
|
|
bq.discard()
|
|
assert.Equal(t, 0, bq.length())
|
|
}
|
|
|
|
// length wraps len access for tests to make them thread-safe.
|
|
func (bq *blockQueue) length() int {
|
|
bq.queueLock.Lock()
|
|
defer bq.queueLock.Unlock()
|
|
return bq.len
|
|
}
|