Merge pull request #4485 from ElrondNetwork/integrate-elrond-go-p2p

Integrate elrond-go-p2p

cmd/seednode/main.go

@@ -23,7 +23,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go/epochStart/bootstrap/disabled"
 	"github.com/ElrondNetwork/elrond-go/facade"
 	"github.com/ElrondNetwork/elrond-go/p2p"
-	"github.com/ElrondNetwork/elrond-go/p2p/libp2p"
+	p2pConfig "github.com/ElrondNetwork/elrond-go/p2p/config"
 	"github.com/urfave/cli"
 )
 
@@ -176,26 +176,26 @@ func startNode(ctx *cli.Context) error {
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 
-	p2pConfig, err := common.LoadP2PConfig(p2pConfigurationFile)
+	p2pCfg, err := common.LoadP2PConfig(p2pConfigurationFile)
 	if err != nil {
 		return err
 	}
 	log.Info("initialized with p2p config",
 		"filename", p2pConfigurationFile,
 	)
 	if ctx.IsSet(port.Name) {
-		p2pConfig.Node.Port = ctx.GlobalString(port.Name)
+		p2pCfg.Node.Port = ctx.GlobalString(port.Name)
 	}
 	if ctx.IsSet(p2pSeed.Name) {
-		p2pConfig.Node.Seed = ctx.GlobalString(p2pSeed.Name)
+		p2pCfg.Node.Seed = ctx.GlobalString(p2pSeed.Name)
 	}
 
-	err = checkExpectedPeerCount(*p2pConfig)
+	err = checkExpectedPeerCount(*p2pCfg)
 	if err != nil {
 		return err
 	}
 
-	messenger, err := createNode(*p2pConfig, internalMarshalizer)
+	messenger, err := createNode(*p2pCfg, internalMarshalizer)
 	if err != nil {
 		return err
 	}
@@ -240,19 +240,19 @@ func loadMainConfig(filepath string) (*config.Config, error) {
 	return cfg, nil
 }
 
-func createNode(p2pConfig config.P2PConfig, marshalizer marshal.Marshalizer) (p2p.Messenger, error) {
-	arg := libp2p.ArgsNetworkMessenger{
+func createNode(p2pConfig p2pConfig.P2PConfig, marshalizer marshal.Marshalizer) (p2p.Messenger, error) {
+	arg := p2p.ArgsNetworkMessenger{
 		Marshalizer:           marshalizer,
-		ListenAddress:         libp2p.ListenAddrWithIp4AndTcp,
+		ListenAddress:         p2p.ListenAddrWithIp4AndTcp,
 		P2pConfig:             p2pConfig,
-		SyncTimer:             &libp2p.LocalSyncTimer{},
+		SyncTimer:             &p2p.LocalSyncTimer{},
 		PreferredPeersHolder:  disabled.NewPreferredPeersHolder(),
 		NodeOperationMode:     p2p.NormalOperation,
 		PeersRatingHandler:    disabled.NewDisabledPeersRatingHandler(),
 		ConnectionWatcherType: "disabled",
 	}
 
-	return libp2p.NewNetworkMessenger(arg)
+	return p2p.NewNetworkMessenger(arg)
 }
 
 func displayMessengerInfo(messenger p2p.Messenger) {
@@ -295,7 +295,7 @@ func getWorkingDir(log logger.Logger) string {
 	return workingDir
 }
 
-func checkExpectedPeerCount(p2pConfig config.P2PConfig) error {
+func checkExpectedPeerCount(p2pConfig p2pConfig.P2PConfig) error {
 	maxExpectedPeerCount := p2pConfig.Node.MaximumExpectedPeerCount
 
 	var rLimit syscall.Rlimit

common/configParser.go

@@ -5,11 +5,12 @@ import (
 
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go/config"
+	p2pConfig "github.com/ElrondNetwork/elrond-go/p2p/config"
 )
 
 // LoadP2PConfig returns a P2PConfig by reading the config file provided
-func LoadP2PConfig(filepath string) (*config.P2PConfig, error) {
-	cfg := &config.P2PConfig{}
+func LoadP2PConfig(filepath string) (*p2pConfig.P2PConfig, error) {
+	cfg := &p2pConfig.P2PConfig{}
 	err := core.LoadTomlFile(cfg, filepath)
 	if err != nil {
 		return nil, err

config/config.go

@@ -1,5 +1,7 @@
 package config
 
+import p2pConfig "github.com/ElrondNetwork/elrond-go/p2p/config"
+
 // CacheConfig will map the cache configuration
 type CacheConfig struct {
 	Name                 string
@@ -562,7 +564,7 @@ type Configs struct {
 	RatingsConfig            *RatingsConfig
 	PreferencesConfig        *Preferences
 	ExternalConfig           *ExternalConfig
-	P2pConfig                *P2PConfig
+	P2pConfig                *p2pConfig.P2PConfig
 	FlagsConfig              *ContextFlagsConfig
 	ImportDbConfig           *ImportDbConfig
 	ConfigurationPathsHolder *ConfigurationPathsHolder

config/tomlConfig_test.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"testing"
 
+	p2pConfig "github.com/ElrondNetwork/elrond-go/p2p/config"
 	"github.com/pelletier/go-toml"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -469,20 +470,20 @@ func TestP2pConfig(t *testing.T) {
     [AdditionalConnections]
         MaxFullHistoryObservers = 0`
 
-	expectedCfg := P2PConfig{
-		Node: NodeConfig{
+	expectedCfg := p2pConfig.P2PConfig{
+		Node: p2pConfig.NodeConfig{
 			Port: port,
 			Seed: seed,
 		},
-		KadDhtPeerDiscovery: KadDhtPeerDiscoveryConfig{
+		KadDhtPeerDiscovery: p2pConfig.KadDhtPeerDiscoveryConfig{
 			ProtocolID:      protocolID,
 			InitialPeerList: []string{initialPeersList},
 		},
-		Sharding: ShardingConfig{
+		Sharding: p2pConfig.ShardingConfig{
 			Type: shardingType,
 		},
 	}
-	cfg := P2PConfig{}
+	cfg := p2pConfig.P2PConfig{}
 
 	err := toml.Unmarshal([]byte(testString), &cfg)
 

dataRetriever/resolvers/topicResolverSender/topicResolverSender.go

@@ -12,7 +12,6 @@ import (
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	resolverDebug "github.com/ElrondNetwork/elrond-go/debug/resolver"
 	"github.com/ElrondNetwork/elrond-go/p2p"
-	"github.com/ElrondNetwork/elrond-go/p2p/message"
 )
 
 const (
@@ -282,7 +281,7 @@ func (trs *topicResolverSender) Send(buff []byte, peer core.PeerID) error {
 }
 
 func (trs *topicResolverSender) sendToConnectedPeer(topic string, buff []byte, peer core.PeerID) error {
-	msg := &message.Message{
+	msg := &p2p.Message{
 		DataField:  buff,
 		PeerField:  peer,
 		TopicField: topic,

factory/networkComponents.go

@@ -13,9 +13,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go/debug/antiflood"
 	"github.com/ElrondNetwork/elrond-go/errors"
 	"github.com/ElrondNetwork/elrond-go/p2p"
-	"github.com/ElrondNetwork/elrond-go/p2p/libp2p"
-	"github.com/ElrondNetwork/elrond-go/p2p/peersHolder"
-	"github.com/ElrondNetwork/elrond-go/p2p/rating"
+	p2pConfig "github.com/ElrondNetwork/elrond-go/p2p/config"
 	"github.com/ElrondNetwork/elrond-go/process"
 	"github.com/ElrondNetwork/elrond-go/process/rating/peerHonesty"
 	antifloodFactory "github.com/ElrondNetwork/elrond-go/process/throttle/antiflood/factory"
@@ -26,7 +24,7 @@ import (
 
 // NetworkComponentsFactoryArgs holds the arguments to create a network component handler instance
 type NetworkComponentsFactoryArgs struct {
-	P2pConfig             config.P2PConfig
+	P2pConfig             p2pConfig.P2PConfig
 	MainConfig            config.Config
 	RatingsConfig         config.RatingsConfig
 	StatusHandler         core.AppStatusHandler
@@ -39,7 +37,7 @@ type NetworkComponentsFactoryArgs struct {
 }
 
 type networkComponentsFactory struct {
-	p2pConfig             config.P2PConfig
+	p2pConfig             p2pConfig.P2PConfig
 	mainConfig            config.Config
 	ratingsConfig         config.RatingsConfig
 	statusHandler         core.AppStatusHandler
@@ -88,7 +86,7 @@ func NewNetworkComponentsFactory(
 		marshalizer:           args.Marshalizer,
 		mainConfig:            args.MainConfig,
 		statusHandler:         args.StatusHandler,
-		listenAddress:         libp2p.ListenAddrWithIp4AndTcp,
+		listenAddress:         p2p.ListenAddrWithIp4AndTcp,
 		syncer:                args.Syncer,
 		bootstrapWaitTime:     args.BootstrapWaitTime,
 		preferredPeersSlices:  args.PreferredPeersSlices,
@@ -99,7 +97,7 @@ func NewNetworkComponentsFactory(
 
 // Create creates and returns the network components
 func (ncf *networkComponentsFactory) Create() (*networkComponents, error) {
-	ph, err := peersHolder.NewPeersHolder(ncf.preferredPeersSlices)
+	ph, err := p2p.NewPeersHolder(ncf.preferredPeersSlices)
 	if err != nil {
 		return nil, err
 	}
@@ -112,16 +110,16 @@ func (ncf *networkComponentsFactory) Create() (*networkComponents, error) {
 	if err != nil {
 		return nil, err
 	}
-	argsPeersRatingHandler := rating.ArgPeersRatingHandler{
+	argsPeersRatingHandler := p2p.ArgPeersRatingHandler{
 		TopRatedCache: topRatedCache,
 		BadRatedCache: badRatedCache,
 	}
-	peersRatingHandler, err := rating.NewPeersRatingHandler(argsPeersRatingHandler)
+	peersRatingHandler, err := p2p.NewPeersRatingHandler(argsPeersRatingHandler)
 	if err != nil {
 		return nil, err
 	}
 
-	arg := libp2p.ArgsNetworkMessenger{
+	arg := p2p.ArgsNetworkMessenger{
 		Marshalizer:           ncf.marshalizer,
 		ListenAddress:         ncf.listenAddress,
 		P2pConfig:             ncf.p2pConfig,
@@ -131,7 +129,7 @@ func (ncf *networkComponentsFactory) Create() (*networkComponents, error) {
 		PeersRatingHandler:    peersRatingHandler,
 		ConnectionWatcherType: ncf.connectionWatcherType,
 	}
-	netMessenger, err := libp2p.NewNetworkMessenger(arg)
+	netMessenger, err := p2p.NewNetworkMessenger(arg)
 	if err != nil {
 		return nil, err
 	}

factory/networkComponents_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/ElrondNetwork/elrond-go/factory"
 	"github.com/ElrondNetwork/elrond-go/factory/mock"
 	"github.com/ElrondNetwork/elrond-go/p2p"
-	"github.com/ElrondNetwork/elrond-go/p2p/libp2p"
+	p2pConfig "github.com/ElrondNetwork/elrond-go/p2p/config"
 	statusHandlerMock "github.com/ElrondNetwork/elrond-go/testscommon/statusHandler"
 	"github.com/stretchr/testify/require"
 )
@@ -60,7 +60,7 @@ func TestNetworkComponentsFactory_CreateShouldErrDueToBadConfig(t *testing.T) {
 
 	args := getNetworkArgs()
 	args.MainConfig = config.Config{}
-	args.P2pConfig = config.P2PConfig{}
+	args.P2pConfig = p2pConfig.P2PConfig{}
 
 	ncf, _ := factory.NewNetworkComponentsFactory(args)
 
@@ -77,7 +77,7 @@ func TestNetworkComponentsFactory_CreateShouldWork(t *testing.T) {
 
 	args := getNetworkArgs()
 	ncf, _ := factory.NewNetworkComponentsFactory(args)
-	ncf.SetListenAddress(libp2p.ListenLocalhostAddrWithIp4AndTcp)
+	ncf.SetListenAddress(p2p.ListenLocalhostAddrWithIp4AndTcp)
 
 	nc, err := ncf.Create()
 	require.NoError(t, err)
@@ -101,12 +101,12 @@ func TestNetworkComponents_CloseShouldWork(t *testing.T) {
 }
 
 func getNetworkArgs() factory.NetworkComponentsFactoryArgs {
-	p2pConfig := config.P2PConfig{
-		Node: config.NodeConfig{
+	p2pCfg := p2pConfig.P2PConfig{
+		Node: p2pConfig.NodeConfig{
 			Port: "0",
 			Seed: "seed",
 		},
-		KadDhtPeerDiscovery: config.KadDhtPeerDiscoveryConfig{
+		KadDhtPeerDiscovery: p2pConfig.KadDhtPeerDiscoveryConfig{
 			Enabled:                          false,
 			Type:                             "optimized",
 			RefreshIntervalInSec:             10,
@@ -115,15 +115,15 @@ func getNetworkArgs() factory.NetworkComponentsFactoryArgs {
 			BucketSize:                       10,
 			RoutingTableRefreshIntervalInSec: 5,
 		},
-		Sharding: config.ShardingConfig{
+		Sharding: p2pConfig.ShardingConfig{
 			TargetPeerCount:         10,
 			MaxIntraShardValidators: 10,
 			MaxCrossShardValidators: 10,
 			MaxIntraShardObservers:  10,
 			MaxCrossShardObservers:  10,
 			MaxSeeders:              2,
 			Type:                    "NilListSharder",
-			AdditionalConnections: config.AdditionalConnectionsConfig{
+			AdditionalConnections: p2pConfig.AdditionalConnectionsConfig{
 				MaxFullHistoryObservers: 10,
 			},
 		},
@@ -155,7 +155,7 @@ func getNetworkArgs() factory.NetworkComponentsFactoryArgs {
 	appStatusHandler := statusHandlerMock.NewAppStatusHandlerMock()
 
 	return factory.NetworkComponentsFactoryArgs{
-		P2pConfig:     p2pConfig,
+		P2pConfig:     p2pCfg,
 		MainConfig:    mainConfig,
 		StatusHandler: appStatusHandler,
 		Marshalizer:   &mock.MarshalizerMock{},
@@ -172,7 +172,7 @@ func getNetworkArgs() factory.NetworkComponentsFactoryArgs {
 				UnitValue:                    1.0,
 			},
 		},
-		Syncer:                &libp2p.LocalSyncTimer{},
+		Syncer:                &p2p.LocalSyncTimer{},
 		NodeOperationMode:     p2p.NormalOperation,
 		ConnectionWatcherType: p2p.ConnectionWatcherTypePrint,
 	}

go.mod

@@ -11,11 +11,10 @@ require (
 	github.com/ElrondNetwork/elrond-go-core v1.1.19
 	github.com/ElrondNetwork/elrond-go-crypto v1.0.1
 	github.com/ElrondNetwork/elrond-go-logger v1.0.7
+	github.com/ElrondNetwork/elrond-go-p2p v0.0.0-20220919155246-aaae1065ad8b
 	github.com/ElrondNetwork/elrond-go-storage v1.0.1
 	github.com/ElrondNetwork/elrond-vm-common v1.3.17
-	github.com/ElrondNetwork/go-libp2p-pubsub v0.6.1-rc1
 	github.com/beevik/ntp v0.3.0
-	github.com/btcsuite/btcd v0.22.0-beta
 	github.com/davecgh/go-spew v1.1.1
 	github.com/elastic/go-elasticsearch/v7 v7.12.0
 	github.com/gin-contrib/cors v0.0.0-20190301062745-f9e10995c85a
@@ -25,20 +24,14 @@ require (
 	github.com/gogo/protobuf v1.3.2
 	github.com/google/gops v0.3.18
 	github.com/gorilla/websocket v1.5.0
-	github.com/ipfs/go-log v1.0.5
-	github.com/jbenet/goprocess v0.1.4
 	github.com/libp2p/go-libp2p v0.19.3
 	github.com/libp2p/go-libp2p-core v0.15.1
-	github.com/libp2p/go-libp2p-kad-dht v0.15.0
-	github.com/libp2p/go-libp2p-kbucket v0.4.7
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/multiformats/go-multiaddr v0.5.0
 	github.com/pelletier/go-toml v1.9.3
 	github.com/pkg/errors v0.9.1
 	github.com/shirou/gopsutil v3.21.11+incompatible
 	github.com/stretchr/testify v1.7.1
 	github.com/urfave/cli v1.22.10
-	github.com/whyrusleeping/timecache v0.0.0-20160911033111-cfcb2f1abfee
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
 	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4
 	golang.org/x/net v0.0.0-20220418201149-a630d4f3e7a2