p2p: support addr format ID@IP:PORT

p2p/connection.go

@@ -88,9 +88,6 @@ type MConnection struct {
 	flushTimer   *cmn.ThrottleTimer // flush writes as necessary but throttled.
 	pingTimer    *cmn.RepeatTimer   // send pings periodically
 	chStatsTimer *cmn.RepeatTimer   // update channel stats periodically
-
-	LocalAddress  *NetAddress
-	RemoteAddress *NetAddress
 }
 
 // MConnConfig is a MConnection configuration.
@@ -140,9 +137,6 @@ func NewMConnectionWithConfig(conn net.Conn, chDescs []*ChannelDescriptor, onRec
 		onReceive:   onReceive,
 		onError:     onError,
 		config:      config,
-
-		LocalAddress:  NewNetAddress(conn.LocalAddr()),
-		RemoteAddress: NewNetAddress(conn.RemoteAddr()),
 	}
 
 	// Create channels

p2p/netaddress.go

@@ -5,6 +5,7 @@
 package p2p
 
 import (
+	"encoding/hex"
 	"flag"
 	"fmt"
 	"net"
@@ -12,6 +13,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/pkg/errors"
 	cmn "github.com/tendermint/tmlibs/common"
 )
 
@@ -29,25 +31,45 @@ type NetAddress struct {
 // using 0.0.0.0:0. When normal run, other net.Addr (except TCP) will
 // panic.
 // TODO: socks proxies?
-func NewNetAddress(addr net.Addr) *NetAddress {
+func NewNetAddress(id ID, addr net.Addr) *NetAddress {
 	tcpAddr, ok := addr.(*net.TCPAddr)
 	if !ok {
 		if flag.Lookup("test.v") == nil { // normal run
 			cmn.PanicSanity(cmn.Fmt("Only TCPAddrs are supported. Got: %v", addr))
 		} else { // in testing
-			return NewNetAddressIPPort(net.IP("0.0.0.0"), 0)
+			netAddr := NewNetAddressIPPort(net.IP("0.0.0.0"), 0)
+			netAddr.ID = id
+			return netAddr
 		}
 	}
 	ip := tcpAddr.IP
 	port := uint16(tcpAddr.Port)
-	return NewNetAddressIPPort(ip, port)
+	netAddr := NewNetAddressIPPort(ip, port)
+	netAddr.ID = id
+	return netAddr
 }
 
 // NewNetAddressString returns a new NetAddress using the provided
 // address in the form of "IP:Port". Also resolves the host if host
 // is not an IP.
 func NewNetAddressString(addr string) (*NetAddress, error) {
-	host, portStr, err := net.SplitHostPort(removeProtocolIfDefined(addr))
+	addr = removeProtocolIfDefined(addr)
+
+	var id ID
+	spl := strings.Split(addr, "@")
+	if len(spl) == 2 {
+		idStr := spl[0]
+		idBytes, err := hex.DecodeString(idStr)
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("Address (%s) contains invalid ID", addr))
+		}
+		if len(idBytes) != 20 {
+			return nil, fmt.Errorf("Address (%s) contains ID of invalid length (%d). Should be 20 hex-encoded bytes", len(idBytes))
+		}
+		id, addr = ID(idStr), spl[1]
+	}
+
+	host, portStr, err := net.SplitHostPort(addr)
 	if err != nil {
 		return nil, err
 	}
@@ -69,6 +91,7 @@ func NewNetAddressString(addr string) (*NetAddress, error) {
 	}
 
 	na := NewNetAddressIPPort(ip, uint16(port))
+	na.ID = id
 	return na, nil
 }
 
@@ -94,10 +117,6 @@ func NewNetAddressIPPort(ip net.IP, port uint16) *NetAddress {
 	na := &NetAddress{
 		IP:   ip,
 		Port: port,
-		str: net.JoinHostPort(
-			ip.String(),
-			strconv.FormatUint(uint64(port), 10),
-		),
 	}
 	return na
 }
@@ -111,23 +130,10 @@ func (na *NetAddress) Equals(other interface{}) bool {
 	return false
 }
 
-func (na *NetAddress) Less(other interface{}) bool {
-	if o, ok := other.(*NetAddress); ok {
-		return na.String() < o.String()
-	}
-
-	cmn.PanicSanity("Cannot compare unequal types")
-	return false
-}
-
-// String representation.
+// String representation: <ID>@<IP>:<PORT>
 func (na *NetAddress) String() string {
 	if na.str == "" {
-
-		addrStr := net.JoinHostPort(
-			na.IP.String(),
-			strconv.FormatUint(uint64(na.Port), 10),
-		)
+		addrStr := na.DialString()
 		if na.ID != "" {
 			addrStr = fmt.Sprintf("%s@%s", na.ID, addrStr)
 		}
@@ -136,9 +142,16 @@ func (na *NetAddress) String() string {
 	return na.str
 }
 
+func (na *NetAddress) DialString() string {
+	return net.JoinHostPort(
+		na.IP.String(),
+		strconv.FormatUint(uint64(na.Port), 10),
+	)
+}
+
 // Dial calls net.Dial on the address.
 func (na *NetAddress) Dial() (net.Conn, error) {
-	conn, err := net.Dial("tcp", na.String())
+	conn, err := net.Dial("tcp", na.DialString())
 	if err != nil {
 		return nil, err
 	}
@@ -147,7 +160,7 @@ func (na *NetAddress) Dial() (net.Conn, error) {
 
 // DialTimeout calls net.DialTimeout on the address.
 func (na *NetAddress) DialTimeout(timeout time.Duration) (net.Conn, error) {
-	conn, err := net.DialTimeout("tcp", na.String(), timeout)
+	conn, err := net.DialTimeout("tcp", na.DialString(), timeout)
 	if err != nil {
 		return nil, err
 	}

p2p/netaddress_test.go

@@ -13,12 +13,12 @@ func TestNewNetAddress(t *testing.T) {
 
 	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
 	require.Nil(err)
-	addr := NewNetAddress(tcpAddr)
+	addr := NewNetAddress("", tcpAddr)
 
 	assert.Equal("127.0.0.1:8080", addr.String())
 
 	assert.NotPanics(func() {
-		NewNetAddress(&net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8000})
+		NewNetAddress("", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8000})
 	}, "Calling NewNetAddress with UDPAddr should not panic in testing")
 }
 
@@ -38,6 +38,16 @@ func TestNewNetAddressString(t *testing.T) {
 		{"notahost:8080", "", false},
 		{"8082", "", false},
 		{"127.0.0:8080000", "", false},
+
+		{"deadbeef@127.0.0.1:8080", "", false},
+		{"this-isnot-hex@127.0.0.1:8080", "", false},
+		{"xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
+		{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", true},
+
+		{"tcp://deadbeef@127.0.0.1:8080", "", false},
+		{"tcp://this-isnot-hex@127.0.0.1:8080", "", false},
+		{"tcp://xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
+		{"tcp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", true},
 	}
 
 	for _, tc := range testCases {

p2p/peer_test.go

@@ -122,7 +122,7 @@ func (p *remotePeer) Start() {
 	if e != nil {
 		golog.Fatalf("net.Listen tcp :0: %+v", e)
 	}
-	p.addr = NewNetAddress(l.Addr())
+	p.addr = NewNetAddress("", l.Addr())
 	p.quit = make(chan struct{})
 	go p.accept(l)
 }

p2p/pex_reactor_test.go

@@ -201,7 +201,7 @@ func createRandomPeer(outbound bool) *peer {
 			PubKey:     crypto.GenPrivKeyEd25519().Wrap().PubKey(),
 		},
 		outbound: outbound,
-		mconn:    &MConnection{RemoteAddress: netAddr},
+		mconn:    &MConnection{},
 	}
 	p.SetLogger(log.TestingLogger().With("peer", addr))
 	return p

p2p/switch.go

@@ -12,6 +12,7 @@ import (
 	crypto "github.com/tendermint/go-crypto"
 	cfg "github.com/tendermint/tendermint/config"
 	cmn "github.com/tendermint/tmlibs/common"
+	"github.com/tendermint/tmlibs/log"
 )
 
 const (
@@ -622,6 +623,7 @@ func makeSwitch(cfg *cfg.P2PConfig, i int, network, version string, initSwitch f
 		ListenAddr: cmn.Fmt("%v:%v", network, rand.Intn(64512)+1023),
 	})
 	s.SetNodeKey(nodeKey)
+	s.SetLogger(log.TestingLogger())
 	return s
 }