add custom error for trie get node

common/constants.go

@@ -834,3 +834,9 @@ const MetricTrieSyncNumReceivedBytes = "erd_trie_sync_num_bytes_received"
 
 // MetricTrieSyncNumProcessedNodes is the metric that outputs the number of trie nodes processed for accounts during trie sync
 const MetricTrieSyncNumProcessedNodes = "erd_trie_sync_num_nodes_processed"
+
+// AccountsTrieIdentifier defines the identifier for accounts trie storer
+const AccountsTrieIdentifier = "AccountsTrie"
+
+// PeerAccountsTrieIdentifier defines the identifier for peer accounts storer
+const PeerAccountsTrieIdentifier = "PeerAccountsTrie"

errors/missingTrieNodeError.go

@@ -1,6 +1,8 @@
 package errors
 
 import (
+	"encoding/hex"
+	"fmt"
 	"strings"
 
 	"github.com/ElrondNetwork/elrond-go/common"
@@ -22,3 +24,39 @@ func IsGetNodeFromDBError(err error) bool {
 
 	return false
 }
+
+// GetNodeFromDBErr defines a custom error for trie get node
+type GetNodeFromDBErr struct {
+	getErr       error
+	key          []byte
+	dbIdentifier string
+}
+
+// NewGetNodeFromDBErr will create a new instance of GetNodeFromDBErr
+func NewGetNodeFromDBErr(key []byte, err error, id string) *GetNodeFromDBErr {
+	return &GetNodeFromDBErr{
+		getErr:       err,
+		key:          key,
+		dbIdentifier: id,
+	}
+}
+
+// Error returns the error as string
+func (e *GetNodeFromDBErr) Error() string {
+	return fmt.Sprintf(
+		"%s: %s for key %v",
+		common.GetNodeFromDBErrorString,
+		e.getErr.Error(),
+		hex.EncodeToString(e.key),
+	)
+}
+
+// GetKey will return the key that generated the error
+func (e *GetNodeFromDBErr) GetKey() []byte {
+	return e.key
+}
+
+// GetIdentifier will return the db corresponding to the db
+func (e *GetNodeFromDBErr) GetIdentifier() string {
+	return e.dbIdentifier
+}

process/sync/baseSync.go

@@ -693,14 +693,9 @@ func (boot *baseBootstrap) handleTrieSyncError(err error, ctx context.Context) {
 	}
 }
 
-func (boot *baseBootstrap) syncUserAccountsState() error {
-	rootHash, err := boot.accounts.RootHash()
-	if err != nil {
-		return err
-	}
-
+func (boot *baseBootstrap) syncUserAccountsState(key []byte) error {
 	log.Warn("base sync: started syncUserAccountsState")
-	return boot.accountsDBSyncer.SyncAccounts(rootHash)
+	return boot.accountsDBSyncer.SyncAccounts(key)
 }
 
 func (boot *baseBootstrap) cleanNoncesSyncedWithErrorsBehindFinal() {

process/sync/export_test.go

@@ -175,6 +175,11 @@ func (boot *MetaBootstrap) GetNotarizedInfo(
 	}
 }
 
+// SyncAccountsDBs -
+func (boot *MetaBootstrap) SyncAccountsDBs(key []byte, id string) error {
+	return boot.syncAccountsDBs(key, id)
+}
+
 // ProcessReceivedHeader -
 func (boot *baseBootstrap) ProcessReceivedHeader(headerHandler data.HeaderHandler, headerHash []byte) {
 	boot.processReceivedHeader(headerHandler, headerHash)

process/sync/metablock.go

@@ -2,11 +2,13 @@ package sync
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/core/check"
 	"github.com/ElrondNetwork/elrond-go-core/data"
 	"github.com/ElrondNetwork/elrond-go-core/data/block"
+	"github.com/ElrondNetwork/elrond-go/common"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	"github.com/ElrondNetwork/elrond-go/errors"
 	"github.com/ElrondNetwork/elrond-go/process"
@@ -180,37 +182,32 @@ func (boot *MetaBootstrap) setLastEpochStartRound() {
 func (boot *MetaBootstrap) SyncBlock(ctx context.Context) error {
 	err := boot.syncBlock()
 	if errors.IsGetNodeFromDBError(err) {
-		errSync := boot.syncAccountsDBs()
+		getNodeErr, ok := err.(*errors.GetNodeFromDBErr)
+		if !ok {
+			return err
+		}
+
+		errSync := boot.syncAccountsDBs(getNodeErr.GetKey(), getNodeErr.GetIdentifier())
 		boot.handleTrieSyncError(errSync, ctx)
 	}
 
 	return err
 }
 
-func (boot *MetaBootstrap) syncAccountsDBs() error {
-	var err error
-
-	err = boot.syncValidatorAccountsState()
-	if err != nil {
-		return err
+func (boot *MetaBootstrap) syncAccountsDBs(key []byte, id string) error {
+	switch id {
+	case common.AccountsTrieIdentifier:
+		return boot.syncUserAccountsState(key)
+	case common.PeerAccountsTrieIdentifier:
+		return boot.syncValidatorAccountsState(key)
+	default:
+		return fmt.Errorf("invalid trie identifier, id: %s", id)
 	}
-
-	err = boot.syncUserAccountsState()
-	if err != nil {
-		return err
-	}
-
-	return nil
 }
 
-func (boot *MetaBootstrap) syncValidatorAccountsState() error {
-	rootHash, err := boot.validatorAccountsDB.RootHash()
-	if err != nil {
-		return err
-	}
-
+func (boot *MetaBootstrap) syncValidatorAccountsState(key []byte) error {
 	log.Warn("base sync: started syncValidatorAccountsState")
-	return boot.validatorStatisticsDBSyncer.SyncAccounts(rootHash)
+	return boot.validatorStatisticsDBSyncer.SyncAccounts(key)
 }
 
 // Close closes the synchronization loop

process/sync/metablock_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go/consensus/round"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever/blockchain"
+	commonErrors "github.com/ElrondNetwork/elrond-go/errors"
 	"github.com/ElrondNetwork/elrond-go/process"
 	"github.com/ElrondNetwork/elrond-go/process/mock"
 	"github.com/ElrondNetwork/elrond-go/process/sync"
@@ -1621,7 +1622,7 @@ func TestMetaBootstrap_SyncBlockErrGetNodeDBShouldSyncAccounts(t *testing.T) {
 	}
 	args.ChainHandler = blkc
 
-	errGetNodeFromDB := errors.New(common.GetNodeFromDBErrorString)
+	errGetNodeFromDB := commonErrors.NewGetNodeFromDBErr([]byte("key"), errors.New("get error"), common.AccountsTrieIdentifier)
 	blockProcessor := createMetaBlockProcessor(args.ChainHandler)
 	blockProcessor.ProcessBlockCalled = func(header data.HeaderHandler, body data.BodyHandler, haveTime func() time.Duration) error {
 		return errGetNodeFromDB
@@ -1680,13 +1681,8 @@ func TestMetaBootstrap_SyncBlockErrGetNodeDBShouldSyncAccounts(t *testing.T) {
 		SyncAccountsCalled: func(rootHash []byte) error {
 			accountsSyncCalled = true
 			return nil
-		}}
-	validatorSyncCalled := false
-	args.ValidatorStatisticsDBSyncer = &mock.AccountsDBSyncerStub{
-		SyncAccountsCalled: func(rootHash []byte) error {
-			validatorSyncCalled = true
-			return nil
-		}}
+		},
+	}
 	args.Accounts = &stateMock.AccountsStub{RootHashCalled: func() ([]byte, error) {
 		return []byte("roothash"), nil
 	}}
@@ -1699,5 +1695,46 @@ func TestMetaBootstrap_SyncBlockErrGetNodeDBShouldSyncAccounts(t *testing.T) {
 
 	assert.Equal(t, errGetNodeFromDB, err)
 	assert.True(t, accountsSyncCalled)
-	assert.True(t, validatorSyncCalled)
+}
+
+func TestMetaBootstrap_SyncAccountsDBs(t *testing.T) {
+	t.Parallel()
+
+	t.Run("sync user accounts state", func(t *testing.T) {
+		t.Parallel()
+
+		args := CreateMetaBootstrapMockArguments()
+		accountsSyncCalled := false
+		args.AccountsDBSyncer = &mock.AccountsDBSyncerStub{
+			SyncAccountsCalled: func(rootHash []byte) error {
+				accountsSyncCalled = true
+				return nil
+			},
+		}
+
+		bs, _ := sync.NewMetaBootstrap(args)
+
+		err := bs.SyncAccountsDBs([]byte("key"), common.AccountsTrieIdentifier)
+		require.Nil(t, err)
+		require.True(t, accountsSyncCalled)
+	})
+
+	t.Run("sync validator accounts state", func(t *testing.T) {
+		t.Parallel()
+
+		args := CreateMetaBootstrapMockArguments()
+		accountsSyncCalled := false
+		args.ValidatorStatisticsDBSyncer = &mock.AccountsDBSyncerStub{
+			SyncAccountsCalled: func(rootHash []byte) error {
+				accountsSyncCalled = true
+				return nil
+			},
+		}
+
+		bs, _ := sync.NewMetaBootstrap(args)
+
+		err := bs.SyncAccountsDBs([]byte("key"), common.PeerAccountsTrieIdentifier)
+		require.Nil(t, err)
+		require.True(t, accountsSyncCalled)
+	})
 }

process/sync/shardblock.go

@@ -144,7 +144,12 @@ func (boot *ShardBootstrap) StartSyncingBlocks() {
 func (boot *ShardBootstrap) SyncBlock(ctx context.Context) error {
 	err := boot.syncBlock()
 	if errors.IsGetNodeFromDBError(err) {
-		errSync := boot.syncUserAccountsState()
+		getNodeErr, ok := err.(*errors.GetNodeFromDBErr)
+		if !ok {
+			return err
+		}
+
+		errSync := boot.syncUserAccountsState(getNodeErr.GetKey())
 		boot.handleTrieSyncError(errSync, ctx)
 	}
 

process/sync/shardblock_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go/consensus/round"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever/blockchain"
+	commonErrors "github.com/ElrondNetwork/elrond-go/errors"
 	"github.com/ElrondNetwork/elrond-go/process"
 	"github.com/ElrondNetwork/elrond-go/process/mock"
 	"github.com/ElrondNetwork/elrond-go/process/sync"
@@ -2061,7 +2062,7 @@ func TestShardBootstrap_SyncBlockGetNodeDBErrorShouldSync(t *testing.T) {
 	}
 	args.ChainHandler = blkc
 
-	errGetNodeFromDB := errors.New(common.GetNodeFromDBErrorString)
+	errGetNodeFromDB := commonErrors.NewGetNodeFromDBErr([]byte("key"), errors.New("get error"), "")
 	blockProcessor := createBlockProcessor(args.ChainHandler)
 	blockProcessor.ProcessBlockCalled = func(header data.HeaderHandler, body data.BodyHandler, haveTime func() time.Duration) error {
 		return errGetNodeFromDB

storage/pruning/pruningStorer.go

@@ -1033,6 +1033,11 @@ func (ps *PruningStorer) RangeKeys(_ func(key []byte, val []byte) bool) {
 	debug.PrintStack()
 }
 
+// GetIdentifier returns the identifier for storer
+func (ps *PruningStorer) GetIdentifier() string {
+	return ps.identifier
+}
+
 // IsInterfaceNil returns true if there is no value under the interface
 func (ps *PruningStorer) IsInterfaceNil() bool {
 	return ps == nil

trie/interface.go

@@ -128,3 +128,7 @@ type storageManagerExtension interface {
 type StorageMarker interface {
 	MarkStorerAsSyncedAndActive(storer common.StorageManager)
 }
+
+type dbWriteCacherWithIdentifier interface {
+	GetIdentifier() string
+}

trie/node.go

@@ -3,8 +3,6 @@ package trie
 
 import (
 	"context"
-	"encoding/hex"
-	"fmt"
 	"time"
 
 	"github.com/ElrondNetwork/elrond-go-core/hashing"
@@ -119,8 +117,14 @@ func computeAndSetNodeHash(n node) ([]byte, error) {
 func getNodeFromDBAndDecode(n []byte, db common.DBWriteCacher, marshalizer marshal.Marshalizer, hasher hashing.Hasher) (node, error) {
 	encChild, err := db.Get(n)
 	if err != nil {
+		dbWithID, ok := db.(dbWriteCacherWithIdentifier)
+		if !ok {
+			log.Warn("wrong type assertion on", common.GetNodeFromDBErrorString, "error", err, "key", n)
+			return nil, errors.NewGetNodeFromDBErr(n, err, "")
+		}
+
 		log.Trace(common.GetNodeFromDBErrorString, "error", err, "key", n)
-		return nil, fmt.Errorf(common.GetNodeFromDBErrorString+" %w for key %v", err, hex.EncodeToString(n))
+		return nil, errors.NewGetNodeFromDBErr(n, err, dbWithID.GetIdentifier())
 	}
 
 	return decodeNode(encChild, marshalizer, hasher)