PeerAuthenticationResolver

dataRetriever/errors.go

@@ -220,3 +220,18 @@ 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")
+
+// ErrPeerAuthNotFound signals that no peer authentication found
+var ErrPeerAuthNotFound = errors.New("peer authentication not found")
+
+// ErrNilNodesCoordinator signals a nil nodes coordinator has been provided
+var ErrNilNodesCoordinator = errors.New("nil nodes coordinator")
+
+// InvalidChunkIndex signals that an invalid chunk was provided
+var InvalidChunkIndex = errors.New("invalid chunk index")
+
+// ErrInvalidNumOfPeerAuthentication signals that an invalid number of peer authentication was provided
+var ErrInvalidNumOfPeerAuthentication = errors.New("invalid num of peer authentication")

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,13 @@ type MiniBlocksResolver interface {
 	RequestDataFromHashArray(hashes [][]byte, epoch uint32) error
 }
 
+// PeerAuthenticationResolver defines what a peer authentication resolver should do
+type PeerAuthenticationResolver interface {
+	Resolver
+	RequestDataFromChunk(chunkIndex uint32, epoch uint32) error
+	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
@@ -414,3 +421,9 @@ type SelfShardIDProvider interface {
 	SelfId() uint32
 	IsInterfaceNil() bool
 }
+
+// NodesCoordinator provides Validator methods needed for the peer processing
+type NodesCoordinator interface {
+	GetAllEligibleValidatorsPublicKeys(epoch uint32) (map[uint32][][]byte, error)
+	IsInterfaceNil() bool
+}

dataRetriever/mock/nodesCoordinatorStub.go

@@ -0,0 +1,20 @@
+package mock
+
+// NodesCoordinatorStub -
+type NodesCoordinatorStub struct {
+	GetAllEligibleValidatorsPublicKeysCalled func(epoch uint32) (map[uint32][][]byte, error)
+}
+
+// GetAllEligibleValidatorsPublicKeys -
+func (nc *NodesCoordinatorStub) GetAllEligibleValidatorsPublicKeys(epoch uint32) (map[uint32][][]byte, error) {
+	if nc.GetAllEligibleValidatorsPublicKeysCalled != nil {
+		return nc.GetAllEligibleValidatorsPublicKeysCalled(epoch)
+	}
+
+	return nil, nil
+}
+
+// IsInterfaceNil -
+func (nc *NodesCoordinatorStub) IsInterfaceNil() bool {
+	return nc == nil
+}

dataRetriever/requestData.proto

@@ -19,6 +19,8 @@ enum RequestDataType {
 	NonceType      = 3;
 	// EpochType indicates that the request data object is of type epoch
 	EpochType      = 4;
+	// ChunkType indicates that the request data object is of type chunk
+	ChunkType      = 5;
 }
 
 // RequestData holds the requested data

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/common_test.go

@@ -11,3 +11,14 @@ func createRequestMsg(dataType dataRetriever.RequestDataType, val []byte) p2p.Me
 	buff, _ := marshalizer.Marshal(&dataRetriever.RequestData{Type: dataType, Value: val})
 	return &mock.P2PMessageMock{DataField: buff}
 }
+
+func createRequestMsgWithChunkIndex(dataType dataRetriever.RequestDataType, val []byte, epoch uint32, chunkIndex uint32) p2p.MessageP2P {
+	marshalizer := &mock.MarshalizerMock{}
+	buff, _ := marshalizer.Marshal(&dataRetriever.RequestData{
+		Type:       dataType,
+		Value:      val,
+		Epoch:      epoch,
+		ChunkIndex: chunkIndex,
+	})
+	return &mock.P2PMessageMock{DataField: buff}
+}