Feat/tanlang/add api to manager p2p net in meassager (#5185)

* feat: move the genesis submodule
from fixtures/networks
to tools/gengen/util

* feat: add some messgaer api
NetFindPeer
NetPeers
NetConnect

* feat: add NetAddrsListen  API

cmd/daemon.go

@@ -149,7 +149,7 @@ func initRun(req *cmds.Request) error {
 		genesisFunc = genesis.MakeGenesis(req.Context, rep, mkGen, preTp.(string), cfg.NetworkParams.ForkUpgradeParam)
 	} else {
 		genesisFileSource, _ := req.Options[GenesisFile].(string)
-		genesisFunc, err = networks.LoadGenesis(req.Context, rep, genesisFileSource, network)
+		genesisFunc, err = genesis.LoadGenesis(req.Context, rep, genesisFileSource, network)
 		if err != nil {
 			return err
 		}

fixtures/networks/network_parse.go

@@ -0,0 +1,66 @@
+package networks
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/venus/pkg/config"
+	"github.com/filecoin-project/venus/venus-shared/types"
+)
+
+func GetNetworkFromName(name string) (types.NetworkType, error) {
+	switch name {
+	case string(types.NetworkNameMain):
+		return types.NetworkMainnet, nil
+	case "force":
+		return types.NetworkForce, nil
+	case string(types.NetworkNameIntegration):
+		return types.Integrationnet, nil
+	case "2k":
+		return types.Network2k, nil
+	case "cali", string(types.NetworkNameCalibration):
+		return types.NetworkCalibnet, nil
+	case "interop", string(types.NetworkNameInterop):
+		return types.NetworkInterop, nil
+	case "butterfly", string(types.NetworkNameButterfly):
+		return types.NetworkButterfly, nil
+	default:
+		return 0, fmt.Errorf("unknown network name %s", name)
+	}
+}
+
+func SetConfigFromOptions(cfg *config.Config, network string) error {
+	netcfg, err := GetNetworkConfig(network)
+	if err != nil {
+		return err
+	}
+	if netcfg != nil {
+		cfg.Bootstrap = &netcfg.Bootstrap
+		cfg.NetworkParams = &netcfg.Network
+	}
+	return nil
+}
+
+func GetNetworkConfig(network string) (*NetworkConf, error) {
+	networkType, err := GetNetworkFromName(network)
+	if err != nil {
+		return nil, err
+	}
+
+	switch networkType {
+	case types.NetworkMainnet:
+		return Mainnet(), nil
+	case types.NetworkForce:
+		return ForceNet(), nil
+	case types.Integrationnet:
+		return IntegrationNet(), nil
+	case types.Network2k:
+		return Net2k(), nil
+	case types.NetworkCalibnet:
+		return Calibration(), nil
+	case types.NetworkInterop:
+		return InteropNet(), nil
+	case types.NetworkButterfly:
+		return ButterflySnapNet(), nil
+	}
+	return nil, fmt.Errorf("unknown network name %s", network)
+}

fixtures/networks/network_parse_test.go

@@ -0,0 +1,154 @@
+package networks
+
+import (
+	"fmt"
+	"testing"
+
+	tf "github.com/filecoin-project/venus/pkg/testhelpers/testflags"
+	"github.com/filecoin-project/venus/venus-shared/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetNetworkFromName(t *testing.T) {
+	tf.UnitTest(t)
+
+	testCast := []struct {
+		name    string
+		network types.NetworkType
+		err     error
+	}{
+		{
+			name:    "mainnet",
+			network: types.NetworkMainnet,
+			err:     nil,
+		},
+		{
+			name:    "force",
+			network: types.NetworkForce,
+			err:     nil,
+		},
+		{
+			name:    "integrationnet",
+			network: types.Integrationnet,
+			err:     nil,
+		},
+		{
+			name:    "2k",
+			network: types.Network2k,
+			err:     nil,
+		},
+		{
+			name:    "cali",
+			network: types.NetworkCalibnet,
+			err:     nil,
+		},
+		{
+			name:    "calibrationnet",
+			network: types.NetworkCalibnet,
+			err:     nil,
+		},
+		{
+			name:    "interop",
+			network: types.NetworkInterop,
+			err:     nil,
+		},
+		{
+			name:    "interopnet",
+			network: types.NetworkInterop,
+			err:     nil,
+		},
+		{
+			name:    "butterfly",
+			network: types.NetworkButterfly,
+			err:     nil,
+		},
+		{
+			name:    "butterflynet",
+			network: types.NetworkButterfly,
+			err:     nil,
+		},
+		{
+			name:    "unknown",
+			network: 0,
+			err:     fmt.Errorf("unknown network name %s", "unknown"),
+		},
+	}
+
+	for _, test := range testCast {
+		network, err := GetNetworkFromName(test.name)
+		assert.Equal(t, test.network, network)
+		assert.Equal(t, test.err, err)
+	}
+}
+
+func TestGetNetworkConfig(t *testing.T) {
+	tf.UnitTest(t)
+
+	testCast := []struct {
+		name    string
+		network *NetworkConf
+		err     error
+	}{
+		{
+			name:    "mainnet",
+			network: Mainnet(),
+			err:     nil,
+		},
+		{
+			name:    "force",
+			network: ForceNet(),
+			err:     nil,
+		},
+		{
+			name:    "integrationnet",
+			network: IntegrationNet(),
+			err:     nil,
+		},
+		{
+			name:    "2k",
+			network: Net2k(),
+			err:     nil,
+		},
+		{
+			name:    "cali",
+			network: Calibration(),
+			err:     nil,
+		},
+		{
+			name:    "calibrationnet",
+			network: Calibration(),
+			err:     nil,
+		},
+		{
+			name:    "interop",
+			network: InteropNet(),
+			err:     nil,
+		},
+		{
+			name:    "interopnet",
+			network: InteropNet(),
+			err:     nil,
+		},
+		{
+			name:    "butterfly",
+			network: ButterflySnapNet(),
+			err:     nil,
+		},
+		{
+			name:    "butterflynet",
+			network: ButterflySnapNet(),
+			err:     nil,
+		},
+		{
+			name:    "unknown",
+			network: nil,
+			err:     fmt.Errorf("unknown network name %s", "unknown"),
+		},
+	}
+
+	for _, test := range testCast {
+		network, err := GetNetworkConfig(test.name)
+		assert.Equal(t, test.network, network)
+		assert.Equal(t, test.err, err)
+	}
+}