PeerAuthenticationResolver

dataRetriever/errors.go

@@ -220,3 +220,12 @@ var ErrNilPathManager = errors.New("nil path manager")
 
 // ErrNilEpochNotifier signals that the provided EpochNotifier is nil
 var ErrNilEpochNotifier = errors.New("nil EpochNotifier")
+
+// ErrNilPeerAuthenticationPool signals that a nil peer authentication pool has been provided
+var ErrNilPeerAuthenticationPool = errors.New("nil peer authentication pool")
+
+// ErrNilHeartbeatPool signals that a nil heartbeat pool has been provided
+var ErrNilHeartbeatPool = errors.New("nil heartbeat pool")
+
+// ErrNotFound signals that a data is missing
+var ErrNotFound = errors.New("data not found")

dataRetriever/factory/resolverscontainer/baseResolversContainerFactory.go

@@ -149,13 +149,15 @@ func (brcf *baseResolversContainerFactory) createTxResolver(
 	}
 
 	arg := resolvers.ArgTxResolver{
-		SenderResolver:    resolverSender,
+		ArgBaseResolver: resolvers.ArgBaseResolver{
+			SenderResolver:   resolverSender,
+			Marshalizer:      brcf.marshalizer,
+			AntifloodHandler: brcf.inputAntifloodHandler,
+			Throttler:        brcf.throttler,
+		},
 		TxPool:            dataPool,
 		TxStorage:         txStorer,
-		Marshalizer:       brcf.marshalizer,
 		DataPacker:        brcf.dataPacker,
-		AntifloodHandler:  brcf.inputAntifloodHandler,
-		Throttler:         brcf.throttler,
 		IsFullHistoryNode: brcf.isFullHistoryNode,
 	}
 	resolver, err := resolvers.NewTxResolver(arg)
@@ -226,12 +228,14 @@ func (brcf *baseResolversContainerFactory) createMiniBlocksResolver(
 	}
 
 	arg := resolvers.ArgMiniblockResolver{
-		SenderResolver:    resolverSender,
+		ArgBaseResolver: resolvers.ArgBaseResolver{
+			SenderResolver:   resolverSender,
+			Marshalizer:      brcf.marshalizer,
+			AntifloodHandler: brcf.inputAntifloodHandler,
+			Throttler:        brcf.throttler,
+		},
 		MiniBlockPool:     brcf.dataPools.MiniBlocks(),
 		MiniBlockStorage:  miniBlocksStorer,
-		Marshalizer:       brcf.marshalizer,
-		AntifloodHandler:  brcf.inputAntifloodHandler,
-		Throttler:         brcf.throttler,
 		DataPacker:        brcf.dataPacker,
 		IsFullHistoryNode: brcf.isFullHistoryNode,
 	}
@@ -328,11 +332,13 @@ func (brcf *baseResolversContainerFactory) createTrieNodesResolver(
 
 	trie := brcf.triesContainer.Get([]byte(trieId))
 	argTrie := resolvers.ArgTrieNodeResolver{
-		SenderResolver:   resolverSender,
-		TrieDataGetter:   trie,
-		Marshalizer:      brcf.marshalizer,
-		AntifloodHandler: brcf.inputAntifloodHandler,
-		Throttler:        brcf.throttler,
+		ArgBaseResolver: resolvers.ArgBaseResolver{
+			SenderResolver:   resolverSender,
+			Marshalizer:      brcf.marshalizer,
+			AntifloodHandler: brcf.inputAntifloodHandler,
+			Throttler:        brcf.throttler,
+		},
+		TrieDataGetter: trie,
 	}
 	resolver, err := resolvers.NewTrieNodeResolver(argTrie)
 	if err != nil {

dataRetriever/factory/resolverscontainer/metaResolversContainerFactory.go

@@ -196,15 +196,17 @@ func (mrcf *metaResolversContainerFactory) createShardHeaderResolver(
 	hdrNonceHashDataUnit := dataRetriever.ShardHdrNonceHashDataUnit + dataRetriever.UnitType(shardID)
 	hdrNonceStore := mrcf.store.GetStorer(hdrNonceHashDataUnit)
 	arg := resolvers.ArgHeaderResolver{
-		SenderResolver:       resolverSender,
+		ArgBaseResolver: resolvers.ArgBaseResolver{
+			SenderResolver:   resolverSender,
+			Marshalizer:      mrcf.marshalizer,
+			AntifloodHandler: mrcf.inputAntifloodHandler,
+			Throttler:        mrcf.throttler,
+		},
 		Headers:              mrcf.dataPools.Headers(),
 		HdrStorage:           hdrStorer,
 		HeadersNoncesStorage: hdrNonceStore,
-		Marshalizer:          mrcf.marshalizer,
 		NonceConverter:       mrcf.uint64ByteSliceConverter,
 		ShardCoordinator:     mrcf.shardCoordinator,
-		AntifloodHandler:     mrcf.inputAntifloodHandler,
-		Throttler:            mrcf.throttler,
 		IsFullHistoryNode:    mrcf.isFullHistoryNode,
 	}
 	resolver, err := resolvers.NewHeaderResolver(arg)
@@ -245,15 +247,17 @@ func (mrcf *metaResolversContainerFactory) createMetaChainHeaderResolver(
 
 	hdrNonceStore := mrcf.store.GetStorer(dataRetriever.MetaHdrNonceHashDataUnit)
 	arg := resolvers.ArgHeaderResolver{
-		SenderResolver:       resolverSender,
+		ArgBaseResolver: resolvers.ArgBaseResolver{
+			SenderResolver:   resolverSender,
+			Marshalizer:      mrcf.marshalizer,
+			AntifloodHandler: mrcf.inputAntifloodHandler,
+			Throttler:        mrcf.throttler,
+		},
 		Headers:              mrcf.dataPools.Headers(),
 		HdrStorage:           hdrStorer,
 		HeadersNoncesStorage: hdrNonceStore,
-		Marshalizer:          mrcf.marshalizer,
 		NonceConverter:       mrcf.uint64ByteSliceConverter,
 		ShardCoordinator:     mrcf.shardCoordinator,
-		AntifloodHandler:     mrcf.inputAntifloodHandler,
-		Throttler:            mrcf.throttler,
 		IsFullHistoryNode:    mrcf.isFullHistoryNode,
 	}
 	resolver, err := resolvers.NewHeaderResolver(arg)

dataRetriever/factory/resolverscontainer/shardResolversContainerFactory.go

@@ -137,15 +137,17 @@ func (srcf *shardResolversContainerFactory) generateHeaderResolvers() error {
 	hdrNonceHashDataUnit := dataRetriever.ShardHdrNonceHashDataUnit + dataRetriever.UnitType(shardC.SelfId())
 	hdrNonceStore := srcf.store.GetStorer(hdrNonceHashDataUnit)
 	arg := resolvers.ArgHeaderResolver{
-		SenderResolver:       resolverSender,
+		ArgBaseResolver: resolvers.ArgBaseResolver{
+			SenderResolver:   resolverSender,
+			Marshalizer:      srcf.marshalizer,
+			AntifloodHandler: srcf.inputAntifloodHandler,
+			Throttler:        srcf.throttler,
+		},
 		Headers:              srcf.dataPools.Headers(),
 		HdrStorage:           hdrStorer,
 		HeadersNoncesStorage: hdrNonceStore,
-		Marshalizer:          srcf.marshalizer,
 		NonceConverter:       srcf.uint64ByteSliceConverter,
 		ShardCoordinator:     srcf.shardCoordinator,
-		AntifloodHandler:     srcf.inputAntifloodHandler,
-		Throttler:            srcf.throttler,
 		IsFullHistoryNode:    srcf.isFullHistoryNode,
 	}
 	resolver, err := resolvers.NewHeaderResolver(arg)
@@ -176,15 +178,17 @@ func (srcf *shardResolversContainerFactory) generateMetablockHeaderResolvers() e
 
 	hdrNonceStore := srcf.store.GetStorer(dataRetriever.MetaHdrNonceHashDataUnit)
 	arg := resolvers.ArgHeaderResolver{
-		SenderResolver:       resolverSender,
+		ArgBaseResolver: resolvers.ArgBaseResolver{
+			SenderResolver:   resolverSender,
+			Marshalizer:      srcf.marshalizer,
+			AntifloodHandler: srcf.inputAntifloodHandler,
+			Throttler:        srcf.throttler,
+		},
 		Headers:              srcf.dataPools.Headers(),
 		HdrStorage:           hdrStorer,
 		HeadersNoncesStorage: hdrNonceStore,
-		Marshalizer:          srcf.marshalizer,
 		NonceConverter:       srcf.uint64ByteSliceConverter,
 		ShardCoordinator:     srcf.shardCoordinator,
-		AntifloodHandler:     srcf.inputAntifloodHandler,
-		Throttler:            srcf.throttler,
 		IsFullHistoryNode:    srcf.isFullHistoryNode,
 	}
 	resolver, err := resolvers.NewHeaderResolver(arg)

dataRetriever/interface.go

@@ -153,6 +153,12 @@ type MiniBlocksResolver interface {
 	RequestDataFromHashArray(hashes [][]byte, epoch uint32) error
 }
 
+// PeerAuthenticationResolver defines what a peer authentication resolver should do
+type PeerAuthenticationResolver interface {
+	Resolver
+	RequestDataFromHashArray(hashes [][]byte, epoch uint32) error
+}
+
 // TopicResolverSender defines what sending operations are allowed for a topic resolver
 type TopicResolverSender interface {
 	SendOnRequestTopic(rd *RequestData, originalHashes [][]byte) error

dataRetriever/resolvers/baseResolver.go

@@ -0,0 +1,55 @@
+package resolvers
+
+import (
+	"github.com/ElrondNetwork/elrond-go-core/core/check"
+	"github.com/ElrondNetwork/elrond-go-core/marshal"
+	"github.com/ElrondNetwork/elrond-go/dataRetriever"
+)
+
+// ArgBaseResolver is the argument structure used as base to create a new a resolver instance
+type ArgBaseResolver struct {
+	SenderResolver   dataRetriever.TopicResolverSender
+	Marshalizer      marshal.Marshalizer
+	AntifloodHandler dataRetriever.P2PAntifloodHandler
+	Throttler        dataRetriever.ResolverThrottler
+}
+
+type baseResolver struct {
+	dataRetriever.TopicResolverSender
+}
+
+func checkArgBase(arg ArgBaseResolver) error {
+	if check.IfNil(arg.SenderResolver) {
+		return dataRetriever.ErrNilResolverSender
+	}
+	if check.IfNil(arg.Marshalizer) {
+		return dataRetriever.ErrNilMarshalizer
+	}
+	if check.IfNil(arg.AntifloodHandler) {
+		return dataRetriever.ErrNilAntifloodHandler
+	}
+	if check.IfNil(arg.Throttler) {
+		return dataRetriever.ErrNilThrottler
+	}
+	return nil
+}
+
+// SetNumPeersToQuery will set the number of intra shard and cross shard number of peer to query
+func (res *baseResolver) SetNumPeersToQuery(intra int, cross int) {
+	res.TopicResolverSender.SetNumPeersToQuery(intra, cross)
+}
+
+// NumPeersToQuery will return the number of intra shard and cross shard number of peer to query
+func (res *baseResolver) NumPeersToQuery() (int, int) {
+	return res.TopicResolverSender.NumPeersToQuery()
+}
+
+// SetResolverDebugHandler will set a resolver debug handler
+func (res *baseResolver) SetResolverDebugHandler(handler dataRetriever.ResolverDebugHandler) error {
+	return res.TopicResolverSender.SetResolverDebugHandler(handler)
+}
+
+// Close returns nil
+func (res *baseResolver) Close() error {
+	return nil
+}

dataRetriever/resolvers/headerResolver.go

@@ -4,7 +4,6 @@ import (
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/core/check"
 	"github.com/ElrondNetwork/elrond-go-core/data/typeConverters"
-	"github.com/ElrondNetwork/elrond-go-core/marshal"
 	"github.com/ElrondNetwork/elrond-go-logger"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever/resolvers/epochproviders/disabled"
@@ -19,22 +18,19 @@ var _ dataRetriever.HeaderResolver = (*HeaderResolver)(nil)
 
 // ArgHeaderResolver is the argument structure used to create new HeaderResolver instance
 type ArgHeaderResolver struct {
-	SenderResolver       dataRetriever.TopicResolverSender
+	ArgBaseResolver
 	Headers              dataRetriever.HeadersPool
 	HdrStorage           storage.Storer
 	HeadersNoncesStorage storage.Storer
-	Marshalizer          marshal.Marshalizer
 	NonceConverter       typeConverters.Uint64ByteSliceConverter
 	ShardCoordinator     sharding.Coordinator
-	AntifloodHandler     dataRetriever.P2PAntifloodHandler
-	Throttler            dataRetriever.ResolverThrottler
 	IsFullHistoryNode    bool
 }
 
 // HeaderResolver is a wrapper over Resolver that is specialized in resolving headers requests
 type HeaderResolver struct {
+	*baseResolver
 	baseStorageResolver
-	dataRetriever.TopicResolverSender
 	messageProcessor
 	headers          dataRetriever.HeadersPool
 	hdrNoncesStorage storage.Storer
@@ -45,37 +41,16 @@ type HeaderResolver struct {
 
 // NewHeaderResolver creates a new header resolver
 func NewHeaderResolver(arg ArgHeaderResolver) (*HeaderResolver, error) {
-	if check.IfNil(arg.SenderResolver) {
-		return nil, dataRetriever.ErrNilResolverSender
-	}
-	if check.IfNil(arg.Headers) {
-		return nil, dataRetriever.ErrNilHeadersDataPool
-	}
-	if check.IfNil(arg.HdrStorage) {
-		return nil, dataRetriever.ErrNilHeadersStorage
-	}
-	if check.IfNil(arg.HeadersNoncesStorage) {
-		return nil, dataRetriever.ErrNilHeadersNoncesStorage
-	}
-	if check.IfNil(arg.Marshalizer) {
-		return nil, dataRetriever.ErrNilMarshalizer
-	}
-	if check.IfNil(arg.NonceConverter) {
-		return nil, dataRetriever.ErrNilUint64ByteSliceConverter
-	}
-	if check.IfNil(arg.ShardCoordinator) {
-		return nil, dataRetriever.ErrNilShardCoordinator
-	}
-	if check.IfNil(arg.AntifloodHandler) {
-		return nil, dataRetriever.ErrNilAntifloodHandler
-	}
-	if check.IfNil(arg.Throttler) {
-		return nil, dataRetriever.ErrNilThrottler
+	err := checkArgHeaderResolver(arg)
+	if err != nil {
+		return nil, err
 	}
 
 	epochHandler := disabled.NewEpochHandler()
 	hdrResolver := &HeaderResolver{
-		TopicResolverSender: arg.SenderResolver,
+		baseResolver: &baseResolver{
+			TopicResolverSender: arg.SenderResolver,
+		},
 		headers:             arg.Headers,
 		baseStorageResolver: createBaseStorageResolver(arg.HdrStorage, arg.IsFullHistoryNode),
 		hdrNoncesStorage:    arg.HeadersNoncesStorage,
@@ -93,6 +68,29 @@ func NewHeaderResolver(arg ArgHeaderResolver) (*HeaderResolver, error) {
 	return hdrResolver, nil
 }
 
+func checkArgHeaderResolver(arg ArgHeaderResolver) error {
+	err := checkArgBase(arg.ArgBaseResolver)
+	if err != nil {
+		return err
+	}
+	if check.IfNil(arg.Headers) {
+		return dataRetriever.ErrNilHeadersDataPool
+	}
+	if check.IfNil(arg.HdrStorage) {
+		return dataRetriever.ErrNilHeadersStorage
+	}
+	if check.IfNil(arg.HeadersNoncesStorage) {
+		return dataRetriever.ErrNilHeadersNoncesStorage
+	}
+	if check.IfNil(arg.NonceConverter) {
+		return dataRetriever.ErrNilUint64ByteSliceConverter
+	}
+	if check.IfNil(arg.ShardCoordinator) {
+		return dataRetriever.ErrNilShardCoordinator
+	}
+	return nil
+}
+
 // SetEpochHandler sets the epoch handler for this component
 func (hdrRes *HeaderResolver) SetEpochHandler(epochHandler dataRetriever.EpochHandler) error {
 	if check.IfNil(epochHandler) {
@@ -264,26 +262,6 @@ func (hdrRes *HeaderResolver) RequestDataFromEpoch(identifier []byte) error {
 	)
 }
 
-// SetNumPeersToQuery will set the number of intra shard and cross shard number of peer to query
-func (hdrRes *HeaderResolver) SetNumPeersToQuery(intra int, cross int) {
-	hdrRes.TopicResolverSender.SetNumPeersToQuery(intra, cross)
-}
-
-// NumPeersToQuery will return the number of intra shard and cross shard number of peer to query
-func (hdrRes *HeaderResolver) NumPeersToQuery() (int, int) {
-	return hdrRes.TopicResolverSender.NumPeersToQuery()
-}
-
-// SetResolverDebugHandler will set a resolver debug handler
-func (hdrRes *HeaderResolver) SetResolverDebugHandler(handler dataRetriever.ResolverDebugHandler) error {
-	return hdrRes.TopicResolverSender.SetResolverDebugHandler(handler)
-}
-
-// Close returns nil
-func (hdrRes *HeaderResolver) Close() error {
-	return nil
-}
-
 // IsInterfaceNil returns true if there is no value under the interface
 func (hdrRes *HeaderResolver) IsInterfaceNil() bool {
 	return hdrRes == nil

dataRetriever/resolvers/headerResolver_test.go

@@ -17,17 +17,23 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func createMockArgBaseResolver() resolvers.ArgBaseResolver {
+	return resolvers.ArgBaseResolver{
+		SenderResolver:   &mock.TopicResolverSenderStub{},
+		Marshalizer:      &mock.MarshalizerMock{},
+		AntifloodHandler: &mock.P2PAntifloodHandlerStub{},
+		Throttler:        &mock.ThrottlerStub{},
+	}
+}
+
 func createMockArgHeaderResolver() resolvers.ArgHeaderResolver {
 	return resolvers.ArgHeaderResolver{
-		SenderResolver:       &mock.TopicResolverSenderStub{},
+		ArgBaseResolver:      createMockArgBaseResolver(),
 		Headers:              &mock.HeadersCacherStub{},
 		HdrStorage:           &storageStubs.StorerStub{},
 		HeadersNoncesStorage: &storageStubs.StorerStub{},
-		Marshalizer:          &mock.MarshalizerMock{},
 		NonceConverter:       mock.NewNonceHashConverterMock(),
 		ShardCoordinator:     mock.NewOneShardCoordinatorMock(),
-		AntifloodHandler:     &mock.P2PAntifloodHandlerStub{},
-		Throttler:            &mock.ThrottlerStub{},
 	}
 }