[GH-846] AddrInfo/AddrInfoSlice reworked

nil/cmd/nil-relay/main.go

@@ -9,6 +9,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/NilFoundation/nil/nil/common/check"
 	"github.com/NilFoundation/nil/nil/common/concurrent"
 	"github.com/NilFoundation/nil/nil/common/logging"
 	"github.com/NilFoundation/nil/nil/internal/cobrax"
@@ -31,8 +32,9 @@ const (
 var logger = logging.NewLogger("relay")
 
 type config struct {
-	LogLevel  string `yaml:"logLevel,omitempty"`
-	PprofPort int    `yaml:"pprofPort,omitempty"`
+	LogLevel       string `yaml:"logLevel,omitempty"`
+	Libp2pLogLevel string `yaml:"libp2pLogLevel,omitempty"`
+	PprofPort      int    `yaml:"pprofPort,omitempty"`
 
 	Network   *network.Config   `yaml:"network,omitempty"`
 	Telemetry *telemetry.Config `yaml:"telemetry,omitempty"`
@@ -62,6 +64,7 @@ func runCommand() error {
 
 	cobrax.AddConfigFlag(rootCmd.PersistentFlags())
 	cobrax.AddLogLevelFlag(rootCmd.PersistentFlags(), &cfg.LogLevel)
+	cobrax.AddCustomLogLevelFlag(rootCmd.PersistentFlags(), "libp2p-log-level", "", &cfg.Libp2pLogLevel)
 	cobrax.AddPprofPortFlag(rootCmd.PersistentFlags(), &cfg.PprofPort)
 	cmdflags.AddNetwork(rootCmd.PersistentFlags(), cfg.Network)
 	cmdflags.AddTelemetry(rootCmd.PersistentFlags(), cfg.Telemetry)
@@ -118,6 +121,7 @@ func genConfig(cfg *config, fileName string) error {
 
 func run(ctx context.Context, cfg *config) error {
 	logging.SetupGlobalLogger(cfg.LogLevel)
+	check.PanicIfErr(logging.SetLibp2pLogLevel(cfg.Libp2pLogLevel))
 	profiling.Start(cfg.PprofPort)
 
 	if err := telemetry.Init(ctx, cfg.Telemetry); err != nil {

nil/cmd/nild/devnet.go

@@ -18,6 +18,7 @@ import (
 	"github.com/NilFoundation/nil/nil/internal/telemetry"
 	"github.com/NilFoundation/nil/nil/services/nilservice"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/spf13/cobra"
 	"gopkg.in/yaml.v3"
 )
@@ -463,7 +464,7 @@ func getPeer(srv server) network.AddrInfo {
 func getPeers(servers []server, indices []int) network.AddrInfoSlice {
 	peers := make(network.AddrInfoSlice, len(indices))
 	for i, idx := range indices {
-		peers[i] = getPeer(servers[idx])
+		peers[i] = peer.AddrInfo(getPeer(servers[idx]))
 	}
 	return peers
 }

nil/common/p_value_slice.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding"
 	"encoding/csv"
-	"fmt"
 	"strings"
 
 	"github.com/spf13/pflag"
@@ -27,7 +26,7 @@ var (
 )
 
 func (s *PValueSlice[T, S]) Set(value string) error {
-	parts, err := readAsCSV(value)
+	parts, err := ReadAsCSV(value)
 	if err != nil {
 		return err
 	}
@@ -56,7 +55,7 @@ func (s *PValueSlice[T, S]) String() string {
 }
 
 func (s *PValueSlice[T, S]) Type() string {
-	return fmt.Sprintf("PValueSlice[%s]", T(new(S)).Type())
+	return "[]" + T(new(S)).Type()
 }
 
 func (s PValueSlice[T, S]) MarshalYAML() (any, error) {
@@ -85,7 +84,7 @@ func (s *PValueSlice[T, S]) UnmarshalYAML(value *yaml.Node) error {
 }
 
 // Copy of private functions from pflag used in stringSliceValue implementation.
-func readAsCSV(val string) ([]string, error) {
+func ReadAsCSV(val string) ([]string, error) {
 	if val == "" {
 		return []string{}, nil
 	}

nil/common/p_value_slice_test.go

@@ -61,7 +61,7 @@ func TestValueSlice_Type(t *testing.T) {
 	t.Parallel()
 
 	var vs PValueSlice[*MockValue, MockValue]
-	require.Equal(t, "PValueSlice[mock]", vs.Type())
+	require.Equal(t, "[]mock", vs.Type())
 }
 
 type TestConfig struct {

nil/internal/collate/syncer.go

@@ -37,7 +37,7 @@ type SyncerConfig struct {
 	Name            string
 	ShardId         types.ShardId
 	Timeout         time.Duration // pull blocks if no new blocks appear in the topic for this duration
-	BootstrapPeers  []network.AddrInfo
+	BootstrapPeers  network.AddrInfoSlice
 	ZeroStateConfig *execution.ZeroStateConfig
 }
 
@@ -130,7 +130,7 @@ func (s *Syncer) fetchRemoteVersion(ctx context.Context) (NodeVersion, error) {
 	var err error
 	for _, peer := range s.config.BootstrapPeers {
 		var peerId network.PeerID
-		peerId, err = s.networkManager.Connect(ctx, peer)
+		peerId, err = s.networkManager.Connect(ctx, network.AddrInfo(peer))
 		if err != nil {
 			continue
 		}
@@ -153,7 +153,7 @@ func (s *Syncer) fetchRemoteVersion(ctx context.Context) (NodeVersion, error) {
 func (s *Syncer) fetchSnapshot(ctx context.Context) error {
 	var err error
 	for _, peer := range s.config.BootstrapPeers {
-		err = fetchSnapshot(ctx, s.networkManager, peer, s.db, s.logger)
+		err = fetchSnapshot(ctx, s.networkManager, network.AddrInfo(peer), s.db, s.logger)
 		if err == nil {
 			return nil
 		}

nil/internal/network/addr_info.go

@@ -2,41 +2,42 @@ package network
 
 import (
 	"errors"
+	"fmt"
+	"slices"
+	"strings"
 
 	"github.com/NilFoundation/nil/nil/common"
 	"github.com/libp2p/go-libp2p/core/peer"
+	ma "github.com/multiformats/go-multiaddr"
+	"github.com/spf13/pflag"
 	"gopkg.in/yaml.v3"
 )
 
 type AddrInfo peer.AddrInfo
 
+var _ pflag.Value = (*AddrInfo)(nil)
+
 func (a AddrInfo) Empty() bool {
 	return errors.Is(a.ID.Validate(), peer.ErrEmptyPeerID)
 }
 
 func (a *AddrInfo) Set(value string) error {
-	addr, err := peer.AddrInfoFromString(value)
+	addrInfos, err := addrInfosFromString(value)
 	if err != nil {
 		return err
 	}
-	*a = AddrInfo(*addr)
+	if len(addrInfos) == 0 {
+		return fmt.Errorf("%s is not a valid address", value)
+	}
+	if len(addrInfos) > 1 {
+		return fmt.Errorf("not all multiaddresses belong to the same peer: %s", value)
+	}
+	*a = AddrInfo(addrInfos[0])
 	return nil
 }
 
 func (a AddrInfo) String() string {
-	mu, err := peer.AddrInfoToP2pAddrs((*peer.AddrInfo)(&a))
-	if err != nil {
-		return err.Error()
-	}
-	values := make([]string, len(mu))
-	for i, val := range mu {
-		values[i] = val.String()
-	}
-	str, err := common.WriteAsCSV(values)
-	if err != nil {
-		return err.Error()
-	}
-	return str
+	return addrInfosToString(peer.AddrInfo(a))
 }
 
 func (a *AddrInfo) Type() string {
@@ -59,12 +60,113 @@ func (a *AddrInfo) UnmarshalYAML(value *yaml.Node) error {
 	return a.UnmarshalText([]byte(value.Value))
 }
 
-type AddrInfoSlice = common.PValueSlice[*AddrInfo, AddrInfo]
+type AddrInfoSlice []peer.AddrInfo
+
+func AsAddrInfoSlice(addrInfos ...AddrInfo) AddrInfoSlice {
+	return slices.Collect(
+		common.Transform(
+			slices.Values(addrInfos),
+			func(a AddrInfo) peer.AddrInfo { return peer.AddrInfo(a) }))
+}
+
+var _ pflag.Value = (*AddrInfoSlice)(nil)
 
-func ToLibP2pAddrInfoSlice(s AddrInfoSlice) []peer.AddrInfo {
-	res := make([]peer.AddrInfo, len(s))
-	for i, a := range s {
-		res[i] = peer.AddrInfo(a)
+func (s *AddrInfoSlice) Set(value string) (err error) {
+	*s, err = addrInfosFromString(value)
+	return
+}
+
+// String returns one multiaddress per item including PeerID, comma-separated
+func (s *AddrInfoSlice) String() string {
+	return addrInfosToString(*s...)
+}
+
+func (s *AddrInfoSlice) Type() string {
+	return "[]AddrInfo"
+}
+
+// Strings returns one multiaddress per item including PeerID, in each array element
+func (s *AddrInfoSlice) Strings() ([]string, error) {
+	return addrInfosToStrings(*s...)
+}
+
+func (s *AddrInfoSlice) FromStrings(addrs []string) (err error) {
+	*s, err = addrInfosFromStrings(addrs)
+	return
+}
+
+func (s AddrInfoSlice) MarshalText() ([]byte, error) {
+	return []byte(s.String()), nil
+}
+
+func (s *AddrInfoSlice) UnmarshalText(text []byte) (err error) {
+	return s.Set(string(text))
+}
+
+func (s AddrInfoSlice) MarshalYAML() (any, error) {
+	return addrInfosToStrings(s...)
+}
+
+func (s *AddrInfoSlice) UnmarshalYAML(node *yaml.Node) error {
+	var addrs []string
+	if err := node.Decode(&addrs); err != nil {
+		return err
+	}
+	return s.FromStrings(addrs)
+}
+
+func addrInfosFromStrings(addrs []string) ([]peer.AddrInfo, error) {
+	var err error
+	mas := make([]ma.Multiaddr, len(addrs))
+	for i, addr := range addrs {
+		mas[i], err = ma.NewMultiaddr(addr)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	addrInfos, err := peer.AddrInfosFromP2pAddrs(mas...)
+	if err != nil {
+		return nil, err
+	}
+	slices.SortFunc(addrInfos, func(l, r peer.AddrInfo) int {
+		return strings.Compare(string(l.ID), string(r.ID))
+	})
+	return addrInfos, nil
+}
+
+func addrInfosFromString(value string) ([]peer.AddrInfo, error) {
+	addrs, err := common.ReadAsCSV(value)
+	if err != nil {
+		return nil, err
+	}
+	return addrInfosFromStrings(addrs)
+}
+
+func addrInfosToStrings(addrInfos ...peer.AddrInfo) ([]string, error) {
+	result := make([]string, 0, len(addrInfos))
+	for _, addrInfo := range addrInfos {
+		multiAddrs, err := peer.AddrInfoToP2pAddrs(&addrInfo)
+		if err != nil {
+			return nil, err
+		}
+		result = slices.AppendSeq(
+			result,
+			common.Transform(
+				slices.Values(multiAddrs),
+				func(addr ma.Multiaddr) string { return addr.String() }))
+	}
+	return result, nil
+}
+
+func addrInfosToString(addrInfos ...peer.AddrInfo) string {
+	addrs, err := addrInfosToStrings(addrInfos...)
+	if err != nil {
+		return err.Error()
+	}
+	result, err := common.WriteAsCSV(addrs)
+	if err != nil {
+		return err.Error()
 	}
-	return res
+	return result
 }