forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-27 07:06:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

core/rawdb: fix snappy

Browse source
This commit is contained in:
Felix Lange 2025-03-15 22:05:15 +01:00
parent 05a1f4fddc
commit 7b51129b0d
6 changed files with 72 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
core/rawdb/ancient_scheme.go
View file

@ -40,14 +40,14 @@ const (
// chainFreezerTableConfigs configures whether compression is disabled for the ancient-tables. // chainFreezerTableConfigs configures whether compression is disabled for the ancient-tables.
// Hashes and difficulties don't compress well. // Hashes and difficulties don't compress well.
var chainFreezerTableConfigs = map[string]freezerTableConfig{ var chainFreezerTableConfigs = map[string]freezerTableConfig{
ChainFreezerHeaderTable: {snappy: false, prunable: false}, ChainFreezerHeaderTable: {noSnappy: false, prunable: false},
ChainFreezerHashTable: {snappy: true, prunable: false}, ChainFreezerHashTable: {noSnappy: true, prunable: false},
ChainFreezerBodiesTable: {snappy: false, prunable: true}, ChainFreezerBodiesTable: {noSnappy: false, prunable: true},
ChainFreezerReceiptTable: {snappy: false, prunable: true}, ChainFreezerReceiptTable: {noSnappy: false, prunable: true},
} }
type freezerTableConfig struct { type freezerTableConfig struct {
snappy bool // enables item compression noSnappy bool // disables item compression
prunable bool // true for tables that can be truncated by TruncateTailBlocks prunable bool // true for tables that can be truncated by TruncateTailBlocks
} }
@ -65,11 +65,11 @@ const (
// stateFreezerTableConfigs configures whether compression is disabled for the state freezer. // stateFreezerTableConfigs configures whether compression is disabled for the state freezer.
var stateFreezerTableConfigs = map[string]freezerTableConfig{ var stateFreezerTableConfigs = map[string]freezerTableConfig{
stateHistoryMeta: {snappy: true, prunable: false}, stateHistoryMeta: {noSnappy: true, prunable: false},
stateHistoryAccountIndex: {snappy: false, prunable: false}, stateHistoryAccountIndex: {noSnappy: false, prunable: false},
stateHistoryStorageIndex: {snappy: false, prunable: false}, stateHistoryStorageIndex: {noSnappy: false, prunable: false},
stateHistoryAccountData: {snappy: false, prunable: false}, stateHistoryAccountData: {noSnappy: false, prunable: false},
stateHistoryStorageData: {snappy: false, prunable: false}, stateHistoryStorageData: {noSnappy: false, prunable: false},
} }
// The list of identifiers of ancient stores. // The list of identifiers of ancient stores.

2
core/rawdb/freezer_batch.go
View file

@ -96,7 +96,7 @@ type freezerTableBatch struct {
// newBatch creates a new batch for the freezer table. // newBatch creates a new batch for the freezer table.
func (t *freezerTable) newBatch() *freezerTableBatch { func (t *freezerTable) newBatch() *freezerTableBatch {
batch := &freezerTableBatch{t: t} batch := &freezerTableBatch{t: t}
if !t.config.snappy { if !t.config.noSnappy {
batch.sb = new(snappyBuffer) batch.sb = new(snappyBuffer)
} }
batch.reset() batch.reset()

4
core/rawdb/freezer_memory_test.go
View file

@ -27,14 +27,14 @@ func TestMemoryFreezer(t *testing.T) {
ancienttest.TestAncientSuite(t, func(kinds []string) ethdb.AncientStore { ancienttest.TestAncientSuite(t, func(kinds []string) ethdb.AncientStore {
tables := make(map[string]freezerTableConfig) tables := make(map[string]freezerTableConfig)
for _, kind := range kinds { for _, kind := range kinds {
tables[kind] = freezerTableConfig{snappy: true} tables[kind] = freezerTableConfig{noSnappy: true}
} }
return NewMemoryFreezer(false, tables) return NewMemoryFreezer(false, tables)
}) })
ancienttest.TestResettableAncientSuite(t, func(kinds []string) ethdb.ResettableAncientStore { ancienttest.TestResettableAncientSuite(t, func(kinds []string) ethdb.ResettableAncientStore {
tables := make(map[string]freezerTableConfig) tables := make(map[string]freezerTableConfig)
for _, kind := range kinds { for _, kind := range kinds {
tables[kind] = freezerTableConfig{snappy: true} tables[kind] = freezerTableConfig{noSnappy: true}
} }
return NewMemoryFreezer(false, tables) return NewMemoryFreezer(false, tables)
}) })

8
core/rawdb/freezer_table.go
View file

@ -138,7 +138,7 @@ func newTable(path string, name string, readMeter, writeMeter *metrics.Meter, si
return nil, err return nil, err
} }
var idxName string var idxName string
if config.snappy { if config.noSnappy {
idxName = fmt.Sprintf("%s.ridx", name) // raw index file idxName = fmt.Sprintf("%s.ridx", name) // raw index file
} else { } else {
idxName = fmt.Sprintf("%s.cidx", name) // compressed index file idxName = fmt.Sprintf("%s.cidx", name) // compressed index file
@ -871,7 +871,7 @@ func (t *freezerTable) openFile(num uint32, opener func(string) (*os.File, error
var exist bool var exist bool
if f, exist = t.files[num]; !exist { if f, exist = t.files[num]; !exist {
var name string var name string
if t.config.snappy { if t.config.noSnappy {
name = fmt.Sprintf("%s.%04d.rdat", t.name, num) name = fmt.Sprintf("%s.%04d.rdat", t.name, num)
} else { } else {
name = fmt.Sprintf("%s.%04d.cdat", t.name, num) name = fmt.Sprintf("%s.%04d.cdat", t.name, num)
@ -987,13 +987,13 @@ func (t *freezerTable) RetrieveItems(start, count, maxBytes uint64) ([][]byte, e
item := diskData[offset : offset+diskSize] item := diskData[offset : offset+diskSize]
offset += diskSize offset += diskSize
decompressedSize := diskSize decompressedSize := diskSize
if !t.config.snappy { if !t.config.noSnappy {
decompressedSize, _ = snappy.DecodedLen(item) decompressedSize, _ = snappy.DecodedLen(item)
} }
if i > 0 && maxBytes != 0 && uint64(outputSize+decompressedSize) > maxBytes { if i > 0 && maxBytes != 0 && uint64(outputSize+decompressedSize) > maxBytes {
break break
} }
if !t.config.snappy { if !t.config.noSnappy {
data, err := snappy.Decode(nil, item) data, err := snappy.Decode(nil, item)
if err != nil { if err != nil {
return nil, err return nil, err

94
core/rawdb/freezer_table_test.go
View file

@ -39,7 +39,7 @@ func TestFreezerBasics(t *testing.T) {
// set cutoff at 50 bytes // set cutoff at 50 bytes
f, err := newTable(os.TempDir(), f, err := newTable(os.TempDir(),
fmt.Sprintf("unittest-%d", rand.Uint64()), fmt.Sprintf("unittest-%d", rand.Uint64()),
metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, false) metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -84,7 +84,7 @@ func TestFreezerBasicsClosing(t *testing.T) {
f *freezerTable f *freezerTable
err error err error
) )
f, err = newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -98,7 +98,7 @@ func TestFreezerBasicsClosing(t *testing.T) {
require.NoError(t, batch.commit()) require.NoError(t, batch.commit())
f.Close() f.Close()
f, err = newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -115,7 +115,7 @@ func TestFreezerBasicsClosing(t *testing.T) {
t.Fatalf("test %d, got \n%x != \n%x", y, got, exp) t.Fatalf("test %d, got \n%x != \n%x", y, got, exp)
} }
f.Close() f.Close()
f, err = newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -130,7 +130,7 @@ func TestFreezerRepairDanglingHead(t *testing.T) {
// Fill table // Fill table
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -159,7 +159,7 @@ func TestFreezerRepairDanglingHead(t *testing.T) {
// Now open it again // Now open it again
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -182,7 +182,7 @@ func TestFreezerRepairDanglingHeadLarge(t *testing.T) {
// Fill a table and close it // Fill a table and close it
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -208,7 +208,7 @@ func TestFreezerRepairDanglingHeadLarge(t *testing.T) {
// Now open it again // Now open it again
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -231,7 +231,7 @@ func TestFreezerRepairDanglingHeadLarge(t *testing.T) {
// And if we open it, we should now be able to read all of them (new values) // And if we open it, we should now be able to read all of them (new values)
{ {
f, _ := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, _ := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
for y := 1; y < 255; y++ { for y := 1; y < 255; y++ {
exp := getChunk(15, ^y) exp := getChunk(15, ^y)
got, err := f.Retrieve(uint64(y)) got, err := f.Retrieve(uint64(y))
@ -253,7 +253,7 @@ func TestSnappyDetection(t *testing.T) {
// Open with snappy // Open with snappy
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -264,7 +264,7 @@ func TestSnappyDetection(t *testing.T) {
// Open with snappy // Open with snappy
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -277,7 +277,7 @@ func TestSnappyDetection(t *testing.T) {
// Open without snappy // Open without snappy
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: false}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: false}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -308,7 +308,7 @@ func TestFreezerRepairDanglingIndex(t *testing.T) {
// Fill a table and close it // Fill a table and close it
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -344,7 +344,7 @@ func TestFreezerRepairDanglingIndex(t *testing.T) {
// 45, 45, 15 // 45, 45, 15
// with 3+3+1 items // with 3+3+1 items
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -365,7 +365,7 @@ func TestFreezerTruncate(t *testing.T) {
// Fill table // Fill table
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -381,7 +381,7 @@ func TestFreezerTruncate(t *testing.T) {
// Reopen, truncate // Reopen, truncate
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -406,7 +406,7 @@ func TestFreezerRepairFirstFile(t *testing.T) {
// Fill table // Fill table
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -439,7 +439,7 @@ func TestFreezerRepairFirstFile(t *testing.T) {
// Reopen // Reopen
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -474,7 +474,7 @@ func TestFreezerReadAndTruncate(t *testing.T) {
// Fill table // Fill table
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -490,7 +490,7 @@ func TestFreezerReadAndTruncate(t *testing.T) {
// Reopen and read all files // Reopen and read all files
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -521,7 +521,7 @@ func TestFreezerOffset(t *testing.T) {
fname := fmt.Sprintf("offset-%d", rand.Uint64()) fname := fmt.Sprintf("offset-%d", rand.Uint64())
// Fill table // Fill table
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -545,7 +545,7 @@ func TestFreezerOffset(t *testing.T) {
f.Close() f.Close()
// Now open again // Now open again
f, err = newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -597,7 +597,7 @@ func TestFreezerOffset(t *testing.T) {
// Check that existing items have been moved to index 1M. // Check that existing items have been moved to index 1M.
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -631,7 +631,7 @@ func TestTruncateTail(t *testing.T) {
fname := fmt.Sprintf("truncate-tail-%d", rand.Uint64()) fname := fmt.Sprintf("truncate-tail-%d", rand.Uint64())
// Fill table // Fill table
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -682,7 +682,7 @@ func TestTruncateTail(t *testing.T) {
// Reopen the table, the deletion information should be persisted as well // Reopen the table, the deletion information should be persisted as well
f.Close() f.Close()
f, err = newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -716,7 +716,7 @@ func TestTruncateTail(t *testing.T) {
// Reopen the table, the above testing should still pass // Reopen the table, the above testing should still pass
f.Close() f.Close()
f, err = newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -772,7 +772,7 @@ func TestTruncateHead(t *testing.T) {
fname := fmt.Sprintf("truncate-head-blow-tail-%d", rand.Uint64()) fname := fmt.Sprintf("truncate-head-blow-tail-%d", rand.Uint64())
// Fill table // Fill table
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -883,7 +883,7 @@ func TestSequentialRead(t *testing.T) {
rm, wm, sg := metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge() rm, wm, sg := metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge()
fname := fmt.Sprintf("batchread-%d", rand.Uint64()) fname := fmt.Sprintf("batchread-%d", rand.Uint64())
{ // Fill table { // Fill table
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -893,7 +893,7 @@ func TestSequentialRead(t *testing.T) {
f.Close() f.Close()
} }
{ // Open it, iterate, verify iteration { // Open it, iterate, verify iteration
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -914,7 +914,7 @@ func TestSequentialRead(t *testing.T) {
} }
{ // Open it, iterate, verify byte limit. The byte limit is less than item { // Open it, iterate, verify byte limit. The byte limit is less than item
// size, so each lookup should only return one item // size, so each lookup should only return one item
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 40, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -943,7 +943,7 @@ func TestSequentialReadByteLimit(t *testing.T) {
rm, wm, sg := metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge() rm, wm, sg := metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge()
fname := fmt.Sprintf("batchread-2-%d", rand.Uint64()) fname := fmt.Sprintf("batchread-2-%d", rand.Uint64())
{ // Fill table { // Fill table
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -965,7 +965,7 @@ func TestSequentialReadByteLimit(t *testing.T) {
{100, 109, 10}, {100, 109, 10},
} { } {
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -993,7 +993,7 @@ func TestSequentialReadNoByteLimit(t *testing.T) {
rm, wm, sg := metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge() rm, wm, sg := metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge()
fname := fmt.Sprintf("batchread-3-%d", rand.Uint64()) fname := fmt.Sprintf("batchread-3-%d", rand.Uint64())
{ // Fill table { // Fill table
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1011,7 +1011,7 @@ func TestSequentialReadNoByteLimit(t *testing.T) {
{31, 30}, {31, 30},
} { } {
{ {
f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, rm, wm, sg, 100, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1038,7 +1038,7 @@ func TestFreezerReadonly(t *testing.T) {
// Case 1: Check it fails on non-existent file. // Case 1: Check it fails on non-existent file.
_, err := newTable(tmpdir, _, err := newTable(tmpdir,
fmt.Sprintf("readonlytest-%d", rand.Uint64()), fmt.Sprintf("readonlytest-%d", rand.Uint64()),
metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, true) metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, true)
if err == nil { if err == nil {
t.Fatal("readonly table instantiation should fail for non-existent table") t.Fatal("readonly table instantiation should fail for non-existent table")
} }
@ -1053,7 +1053,7 @@ func TestFreezerReadonly(t *testing.T) {
idxFile.Write(make([]byte, 17)) idxFile.Write(make([]byte, 17))
idxFile.Close() idxFile.Close()
_, err = newTable(tmpdir, fname, _, err = newTable(tmpdir, fname,
metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, true) metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, true)
if err == nil { if err == nil {
t.Errorf("readonly table instantiation should fail for invalid index size") t.Errorf("readonly table instantiation should fail for invalid index size")
} }
@ -1063,7 +1063,7 @@ func TestFreezerReadonly(t *testing.T) {
// again in readonly triggers an error. // again in readonly triggers an error.
fname = fmt.Sprintf("readonlytest-%d", rand.Uint64()) fname = fmt.Sprintf("readonlytest-%d", rand.Uint64())
f, err := newTable(tmpdir, fname, f, err := newTable(tmpdir, fname,
metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, false) metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatalf("failed to instantiate table: %v", err) t.Fatalf("failed to instantiate table: %v", err)
} }
@ -1076,7 +1076,7 @@ func TestFreezerReadonly(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
_, err = newTable(tmpdir, fname, _, err = newTable(tmpdir, fname,
metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, true) metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, true)
if err == nil { if err == nil {
t.Errorf("readonly table instantiation should fail for corrupt table file") t.Errorf("readonly table instantiation should fail for corrupt table file")
} }
@ -1085,7 +1085,7 @@ func TestFreezerReadonly(t *testing.T) {
// Should be successful. // Should be successful.
fname = fmt.Sprintf("readonlytest-%d", rand.Uint64()) fname = fmt.Sprintf("readonlytest-%d", rand.Uint64())
f, err = newTable(tmpdir, fname, f, err = newTable(tmpdir, fname,
metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, false) metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatalf("failed to instantiate table: %v\n", err) t.Fatalf("failed to instantiate table: %v\n", err)
} }
@ -1094,7 +1094,7 @@ func TestFreezerReadonly(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
f, err = newTable(tmpdir, fname, f, err = newTable(tmpdir, fname,
metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, true) metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, true)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1234,7 +1234,7 @@ func (randTest) Generate(r *rand.Rand, size int) reflect.Value {
func runRandTest(rt randTest) bool { func runRandTest(rt randTest) bool {
fname := fmt.Sprintf("randtest-%d", rand.Uint64()) fname := fmt.Sprintf("randtest-%d", rand.Uint64())
f, err := newTable(os.TempDir(), fname, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fname, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
panic("failed to initialize table") panic("failed to initialize table")
} }
@ -1243,7 +1243,7 @@ func runRandTest(rt randTest) bool {
switch step.op { switch step.op {
case opReload: case opReload:
f.Close() f.Close()
f, err = newTable(os.TempDir(), fname, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fname, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 50, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
rt[i].err = fmt.Errorf("failed to reload table %v", err) rt[i].err = fmt.Errorf("failed to reload table %v", err)
} }
@ -1381,7 +1381,7 @@ func TestIndexValidation(t *testing.T) {
} }
for _, c := range cases { for _, c := range cases {
fn := fmt.Sprintf("t-%d", rand.Uint64()) fn := fmt.Sprintf("t-%d", rand.Uint64())
f, err := newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 10*dataSize, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 10*dataSize, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1392,7 +1392,7 @@ func TestIndexValidation(t *testing.T) {
f.Close() f.Close()
// reopen the table, corruption should be truncated // reopen the table, corruption should be truncated
f, err = newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 100, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), 100, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1422,7 +1422,7 @@ func TestFlushOffsetTracking(t *testing.T) {
fileSize = 100 fileSize = 100
) )
fn := fmt.Sprintf("t-%d", rand.Uint64()) fn := fmt.Sprintf("t-%d", rand.Uint64())
f, err := newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), fileSize, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), fileSize, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1533,7 +1533,7 @@ func TestTailTruncationCrash(t *testing.T) {
fileSize = 100 fileSize = 100
) )
fn := fmt.Sprintf("t-%d", rand.Uint64()) fn := fmt.Sprintf("t-%d", rand.Uint64())
f, err := newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), fileSize, freezerTableConfig{snappy: true}, false) f, err := newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), fileSize, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -1563,7 +1563,7 @@ func TestTailTruncationCrash(t *testing.T) {
// the offset // the offset
f.metadata.setFlushOffset(31*indexEntrySize, true) f.metadata.setFlushOffset(31*indexEntrySize, true)
f, err = newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), fileSize, freezerTableConfig{snappy: true}, false) f, err = newTable(os.TempDir(), fn, metrics.NewMeter(), metrics.NewMeter(), metrics.NewGauge(), fileSize, freezerTableConfig{noSnappy: true}, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

16
core/rawdb/freezer_test.go
View file

@ -31,7 +31,7 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
var freezerTestTableDef = map[string]freezerTableConfig{"test": {snappy: true}} var freezerTestTableDef = map[string]freezerTableConfig{"test": {noSnappy: true}}
func TestFreezerModify(t *testing.T) { func TestFreezerModify(t *testing.T) {
t.Parallel() t.Parallel()
@ -47,7 +47,7 @@ func TestFreezerModify(t *testing.T) {
valuesRLP = append(valuesRLP, iv) valuesRLP = append(valuesRLP, iv)
} }
tables := map[string]freezerTableConfig{"raw": {snappy: true}, "rlp": {snappy: false}} tables := map[string]freezerTableConfig{"raw": {noSnappy: true}, "rlp": {noSnappy: false}}
f, _ := newFreezerForTesting(t, tables) f, _ := newFreezerForTesting(t, tables)
defer f.Close() defer f.Close()
@ -111,7 +111,7 @@ func TestFreezerModifyRollback(t *testing.T) {
f.Close() f.Close()
// Reopen and check that the rolled-back data doesn't reappear. // Reopen and check that the rolled-back data doesn't reappear.
tables := map[string]freezerTableConfig{"test": {snappy: true}} tables := map[string]freezerTableConfig{"test": {noSnappy: true}}
f2, err := NewFreezer(dir, "", false, 2049, tables) f2, err := NewFreezer(dir, "", false, 2049, tables)
if err != nil { if err != nil {
t.Fatalf("can't reopen freezer after failed ModifyAncients: %v", err) t.Fatalf("can't reopen freezer after failed ModifyAncients: %v", err)
@ -249,7 +249,7 @@ func TestFreezerConcurrentModifyTruncate(t *testing.T) {
} }
func TestFreezerReadonlyValidate(t *testing.T) { func TestFreezerReadonlyValidate(t *testing.T) {
tables := map[string]freezerTableConfig{"a": {snappy: true}, "b": {snappy: true}} tables := map[string]freezerTableConfig{"a": {noSnappy: true}, "b": {noSnappy: true}}
dir := t.TempDir() dir := t.TempDir()
// Open non-readonly freezer and fill individual tables // Open non-readonly freezer and fill individual tables
// with different amount of data. // with different amount of data.
@ -285,7 +285,7 @@ func TestFreezerReadonlyValidate(t *testing.T) {
func TestFreezerConcurrentReadonly(t *testing.T) { func TestFreezerConcurrentReadonly(t *testing.T) {
t.Parallel() t.Parallel()
tables := map[string]freezerTableConfig{"a": {snappy: true}} tables := map[string]freezerTableConfig{"a": {noSnappy: true}}
dir := t.TempDir() dir := t.TempDir()
f, err := NewFreezer(dir, "", false, 2049, tables) f, err := NewFreezer(dir, "", false, 2049, tables)
@ -379,7 +379,7 @@ func checkAncientCount(t *testing.T, f *Freezer, kind string, n uint64) {
func TestFreezerCloseSync(t *testing.T) { func TestFreezerCloseSync(t *testing.T) {
t.Parallel() t.Parallel()
f, _ := newFreezerForTesting(t, map[string]freezerTableConfig{"a": {snappy: true}, "b": {snappy: true}}) f, _ := newFreezerForTesting(t, map[string]freezerTableConfig{"a": {noSnappy: true}, "b": {noSnappy: true}})
defer f.Close() defer f.Close()
// Now, close and sync. This mimics the behaviour if the node is shut down, // Now, close and sync. This mimics the behaviour if the node is shut down,
@ -403,7 +403,7 @@ func TestFreezerSuite(t *testing.T) {
ancienttest.TestAncientSuite(t, func(kinds []string) ethdb.AncientStore { ancienttest.TestAncientSuite(t, func(kinds []string) ethdb.AncientStore {
tables := make(map[string]freezerTableConfig) tables := make(map[string]freezerTableConfig)
for _, kind := range kinds { for _, kind := range kinds {
tables[kind] = freezerTableConfig{snappy: true} tables[kind] = freezerTableConfig{noSnappy: true}
} }
f, _ := newFreezerForTesting(t, tables) f, _ := newFreezerForTesting(t, tables)
return f return f
@ -411,7 +411,7 @@ func TestFreezerSuite(t *testing.T) {
ancienttest.TestResettableAncientSuite(t, func(kinds []string) ethdb.ResettableAncientStore { ancienttest.TestResettableAncientSuite(t, func(kinds []string) ethdb.ResettableAncientStore {
tables := make(map[string]freezerTableConfig) tables := make(map[string]freezerTableConfig)
for _, kind := range kinds { for _, kind := range kinds {
tables[kind] = freezerTableConfig{snappy: true} tables[kind] = freezerTableConfig{noSnappy: true}
} }
f, _ := newResettableFreezer(t.TempDir(), "", false, 2048, tables) f, _ := newResettableFreezer(t.TempDir(), "", false, 2048, tables)
return f return f