From 63bb7302753653c96798c4b61755f41052d977d8 Mon Sep 17 00:00:00 2001 From: Sina Mahmoodi Date: Thu, 10 Apr 2025 12:24:21 +0200 Subject: [PATCH] instantiate eradb outside of freezer --- core/rawdb/chain_freezer.go | 9 ++++++++- core/rawdb/freezer.go | 20 +++++++------------- core/rawdb/freezer_resettable.go | 2 +- core/rawdb/freezer_test.go | 12 ++++++------ 4 files changed, 22 insertions(+), 21 deletions(-) diff --git a/core/rawdb/chain_freezer.go b/core/rawdb/chain_freezer.go index cc7a62df32..1341fcab15 100644 --- a/core/rawdb/chain_freezer.go +++ b/core/rawdb/chain_freezer.go @@ -19,10 +19,12 @@ package rawdb import ( "errors" "fmt" + "path" "sync" "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb/eradb" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" @@ -64,7 +66,12 @@ func newChainFreezer(datadir string, namespace string, readonly bool) (*chainFre if datadir == "" { freezer = NewMemoryFreezer(readonly, chainFreezerTableConfigs) } else { - freezer, err = NewFreezer(datadir, namespace, readonly, freezerTableSize, chainFreezerTableConfigs) + eraDatadir := path.Join(datadir, "era") + eradb, err := eradb.New(eraDatadir) + if err != nil { + return nil, err + } + freezer, err = NewFreezer(datadir, namespace, readonly, freezerTableSize, chainFreezerTableConfigs, eradb) } if err != nil { return nil, err diff --git a/core/rawdb/freezer.go b/core/rawdb/freezer.go index 28c01e729c..ca865b9222 100644 --- a/core/rawdb/freezer.go +++ b/core/rawdb/freezer.go @@ -81,7 +81,7 @@ type Freezer struct { // // The 'tables' argument defines the data tables. If the value of a map // entry is true, snappy compression is disabled for the table. -func NewFreezer(datadir string, namespace string, readonly bool, maxTableSize uint32, tables map[string]freezerTableConfig) (*Freezer, error) { +func NewFreezer(datadir string, namespace string, readonly bool, maxTableSize uint32, tables map[string]freezerTableConfig, eradb *eradb.EraDatabase) (*Freezer, error) { // Create the initial freezer object var ( readMeter = metrics.NewRegisteredMeter(namespace+"ancient/read", nil) @@ -121,18 +121,9 @@ func NewFreezer(datadir string, namespace string, readonly bool, maxTableSize ui readonly: readonly, tables: make(map[string]*freezerTable), instanceLock: lock, + eradb: eradb, } - // Create the era database. - // TODO: Pipe down network name. - eradir := filepath.Join(datadir, "eradb") - edb, err := eradb.New(eradir) - if err != nil { - lock.Unlock() - return nil, err - } - freezer.eradb = edb - // Create the tables. for name, config := range tables { table, err := newTable(datadir, name, readMeter, writeMeter, sizeGauge, maxTableSize, config, readonly) @@ -145,6 +136,7 @@ func NewFreezer(datadir string, namespace string, readonly bool, maxTableSize ui } freezer.tables[name] = table } + var err error if freezer.readonly { // In readonly mode only validate, don't truncate. // validate also sets `freezer.frozen`. @@ -183,7 +175,9 @@ func (f *Freezer) Close() error { if err := f.instanceLock.Unlock(); err != nil { errs = append(errs, err) } - f.eradb.Close() + if f.eradb != nil { + f.eradb.Close() + } }) if errs != nil { return fmt.Errorf("%v", errs) @@ -208,7 +202,7 @@ func (f *Freezer) HasAncient(kind string, number uint64) (bool, error) { // Ancient retrieves an ancient binary blob from the append-only immutable files. func (f *Freezer) Ancient(kind string, number uint64) ([]byte, error) { if table := f.tables[kind]; table != nil { - if table.config.prunable && number < f.tail.Load() { + if f.eradb != nil && table.config.prunable && number < f.tail.Load() { // The requested item has been pruned. Attempt fetching from era1 file. switch kind { case ChainFreezerBodiesTable: diff --git a/core/rawdb/freezer_resettable.go b/core/rawdb/freezer_resettable.go index 01df2877d9..2be5cee0d4 100644 --- a/core/rawdb/freezer_resettable.go +++ b/core/rawdb/freezer_resettable.go @@ -54,7 +54,7 @@ func newResettableFreezer(datadir string, namespace string, readonly bool, maxTa return nil, err } opener := func() (*Freezer, error) { - return NewFreezer(datadir, namespace, readonly, maxTableSize, tables) + return NewFreezer(datadir, namespace, readonly, maxTableSize, tables, nil) } freezer, err := opener() if err != nil { diff --git a/core/rawdb/freezer_test.go b/core/rawdb/freezer_test.go index a7a3559ec4..2500121ed8 100644 --- a/core/rawdb/freezer_test.go +++ b/core/rawdb/freezer_test.go @@ -112,7 +112,7 @@ func TestFreezerModifyRollback(t *testing.T) { // Reopen and check that the rolled-back data doesn't reappear. tables := map[string]freezerTableConfig{"test": {noSnappy: true}} - f2, err := NewFreezer(dir, "", false, 2049, tables) + f2, err := NewFreezer(dir, "", false, 2049, tables, nil) if err != nil { t.Fatalf("can't reopen freezer after failed ModifyAncients: %v", err) } @@ -253,7 +253,7 @@ func TestFreezerReadonlyValidate(t *testing.T) { dir := t.TempDir() // Open non-readonly freezer and fill individual tables // with different amount of data. - f, err := NewFreezer(dir, "", false, 2049, tables) + f, err := NewFreezer(dir, "", false, 2049, tables, nil) if err != nil { t.Fatal("can't open freezer", err) } @@ -276,7 +276,7 @@ func TestFreezerReadonlyValidate(t *testing.T) { // Re-opening as readonly should fail when validating // table lengths. - _, err = NewFreezer(dir, "", true, 2049, tables) + _, err = NewFreezer(dir, "", true, 2049, tables, nil) if err == nil { t.Fatal("readonly freezer should fail with differing table lengths") } @@ -288,7 +288,7 @@ func TestFreezerConcurrentReadonly(t *testing.T) { tables := map[string]freezerTableConfig{"a": {noSnappy: true}} dir := t.TempDir() - f, err := NewFreezer(dir, "", false, 2049, tables) + f, err := NewFreezer(dir, "", false, 2049, tables, nil) if err != nil { t.Fatal("can't open freezer", err) } @@ -314,7 +314,7 @@ func TestFreezerConcurrentReadonly(t *testing.T) { go func(i int) { defer wg.Done() - f, err := NewFreezer(dir, "", true, 2049, tables) + f, err := NewFreezer(dir, "", true, 2049, tables, nil) if err == nil { fs[i] = f } else { @@ -339,7 +339,7 @@ func newFreezerForTesting(t *testing.T, tables map[string]freezerTableConfig) (* dir := t.TempDir() // note: using low max table size here to ensure the tests actually // switch between multiple files. - f, err := NewFreezer(dir, "", false, 2049, tables) + f, err := NewFreezer(dir, "", false, 2049, tables, nil) if err != nil { t.Fatal("can't open freezer", err) }