You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
184 lines
4.7 KiB
184 lines
4.7 KiB
package consensus
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
// "sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/tendermint/tendermint/consensus/types"
|
|
"github.com/tendermint/tendermint/libs/autofile"
|
|
tmtypes "github.com/tendermint/tendermint/types"
|
|
tmtime "github.com/tendermint/tendermint/types/time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestWALTruncate(t *testing.T) {
|
|
walDir, err := ioutil.TempDir("", "wal")
|
|
if err != nil {
|
|
panic(fmt.Errorf("failed to create temp WAL file: %v", err))
|
|
}
|
|
defer os.RemoveAll(walDir)
|
|
|
|
walFile := filepath.Join(walDir, "wal")
|
|
|
|
//this magic number 4K can truncate the content when RotateFile. defaultHeadSizeLimit(10M) is hard to simulate.
|
|
//this magic number 1 * time.Millisecond make RotateFile check frequently. defaultGroupCheckDuration(5s) is hard to simulate.
|
|
wal, err := NewWAL(walFile, autofile.GroupHeadSizeLimit(4096), autofile.GroupCheckDuration(1*time.Millisecond))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
wal.Start()
|
|
defer wal.Stop()
|
|
|
|
//60 block's size nearly 70K, greater than group's headBuf size(4096 * 10), when headBuf is full, truncate content will Flush to the file.
|
|
//at this time, RotateFile is called, truncate content exist in each file.
|
|
err = WALGenerateNBlocks(wal.Group(), 60)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
time.Sleep(1 * time.Millisecond) //wait groupCheckDuration, make sure RotateFile run
|
|
|
|
wal.Group().Flush()
|
|
|
|
h := int64(50)
|
|
gr, found, err := wal.SearchForEndHeight(h, &WALSearchOptions{})
|
|
assert.NoError(t, err, fmt.Sprintf("expected not to err on height %d", h))
|
|
assert.True(t, found, fmt.Sprintf("expected to find end height for %d", h))
|
|
assert.NotNil(t, gr, "expected group not to be nil")
|
|
defer gr.Close()
|
|
|
|
dec := NewWALDecoder(gr)
|
|
msg, err := dec.Decode()
|
|
assert.NoError(t, err, "expected to decode a message")
|
|
rs, ok := msg.Msg.(tmtypes.EventDataRoundState)
|
|
assert.True(t, ok, "expected message of type EventDataRoundState")
|
|
assert.Equal(t, rs.Height, h+1, fmt.Sprintf("wrong height"))
|
|
}
|
|
|
|
func TestWALEncoderDecoder(t *testing.T) {
|
|
now := tmtime.Now()
|
|
msgs := []TimedWALMessage{
|
|
TimedWALMessage{Time: now, Msg: EndHeightMessage{0}},
|
|
TimedWALMessage{Time: now, Msg: timeoutInfo{Duration: time.Second, Height: 1, Round: 1, Step: types.RoundStepPropose}},
|
|
}
|
|
|
|
b := new(bytes.Buffer)
|
|
|
|
for _, msg := range msgs {
|
|
b.Reset()
|
|
|
|
enc := NewWALEncoder(b)
|
|
err := enc.Encode(&msg)
|
|
require.NoError(t, err)
|
|
|
|
dec := NewWALDecoder(b)
|
|
decoded, err := dec.Decode()
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, msg.Time.UTC(), decoded.Time)
|
|
assert.Equal(t, msg.Msg, decoded.Msg)
|
|
}
|
|
}
|
|
|
|
func TestWALSearchForEndHeight(t *testing.T) {
|
|
walBody, err := WALWithNBlocks(6)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
walFile := tempWALWithData(walBody)
|
|
|
|
wal, err := NewWAL(walFile)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
h := int64(3)
|
|
gr, found, err := wal.SearchForEndHeight(h, &WALSearchOptions{})
|
|
assert.NoError(t, err, fmt.Sprintf("expected not to err on height %d", h))
|
|
assert.True(t, found, fmt.Sprintf("expected to find end height for %d", h))
|
|
assert.NotNil(t, gr, "expected group not to be nil")
|
|
defer gr.Close()
|
|
|
|
dec := NewWALDecoder(gr)
|
|
msg, err := dec.Decode()
|
|
assert.NoError(t, err, "expected to decode a message")
|
|
rs, ok := msg.Msg.(tmtypes.EventDataRoundState)
|
|
assert.True(t, ok, "expected message of type EventDataRoundState")
|
|
assert.Equal(t, rs.Height, h+1, fmt.Sprintf("wrong height"))
|
|
}
|
|
|
|
/*
|
|
var initOnce sync.Once
|
|
|
|
func registerInterfacesOnce() {
|
|
initOnce.Do(func() {
|
|
var _ = wire.RegisterInterface(
|
|
struct{ WALMessage }{},
|
|
wire.ConcreteType{[]byte{}, 0x10},
|
|
)
|
|
})
|
|
}
|
|
*/
|
|
|
|
func nBytes(n int) []byte {
|
|
buf := make([]byte, n)
|
|
n, _ = rand.Read(buf)
|
|
return buf[:n]
|
|
}
|
|
|
|
func benchmarkWalDecode(b *testing.B, n int) {
|
|
// registerInterfacesOnce()
|
|
|
|
buf := new(bytes.Buffer)
|
|
enc := NewWALEncoder(buf)
|
|
|
|
data := nBytes(n)
|
|
enc.Encode(&TimedWALMessage{Msg: data, Time: time.Now().Round(time.Second).UTC()})
|
|
|
|
encoded := buf.Bytes()
|
|
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
buf.Reset()
|
|
buf.Write(encoded)
|
|
dec := NewWALDecoder(buf)
|
|
if _, err := dec.Decode(); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
b.ReportAllocs()
|
|
}
|
|
|
|
func BenchmarkWalDecode512B(b *testing.B) {
|
|
benchmarkWalDecode(b, 512)
|
|
}
|
|
|
|
func BenchmarkWalDecode10KB(b *testing.B) {
|
|
benchmarkWalDecode(b, 10*1024)
|
|
}
|
|
func BenchmarkWalDecode100KB(b *testing.B) {
|
|
benchmarkWalDecode(b, 100*1024)
|
|
}
|
|
func BenchmarkWalDecode1MB(b *testing.B) {
|
|
benchmarkWalDecode(b, 1024*1024)
|
|
}
|
|
func BenchmarkWalDecode10MB(b *testing.B) {
|
|
benchmarkWalDecode(b, 10*1024*1024)
|
|
}
|
|
func BenchmarkWalDecode100MB(b *testing.B) {
|
|
benchmarkWalDecode(b, 100*1024*1024)
|
|
}
|
|
func BenchmarkWalDecode1GB(b *testing.B) {
|
|
benchmarkWalDecode(b, 1024*1024*1024)
|
|
}
|