P2P now works with Amino

p2p/peer.go

@@ -5,10 +5,7 @@ import (
 	"net"
 	"time"
 
-	"github.com/pkg/errors"
-
-	crypto "github.com/tendermint/go-crypto"
-	wire "github.com/tendermint/go-wire"
+	"github.com/tendermint/go-crypto"
 	cmn "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/log"
 
@@ -25,8 +22,8 @@ type Peer interface {
 	NodeInfo() NodeInfo // peer's info
 	Status() tmconn.ConnectionStatus
 
-	Send(byte, interface{}) bool
-	TrySend(byte, interface{}) bool
+	Send(byte, []byte) bool
+	TrySend(byte, []byte) bool
 
 	Set(string, interface{})
 	Get(string) interface{}
@@ -114,13 +111,13 @@ func newOutboundPeerConn(addr *NetAddress, config *PeerConfig, persistent bool,
 
 	conn, err := dial(addr, config)
 	if err != nil {
-		return pc, errors.Wrap(err, "Error creating peer")
+		return pc, cmn.ErrorWrap(err, "Error creating peer")
 	}
 
 	pc, err = newPeerConn(conn, config, true, persistent, ourNodePrivKey)
 	if err != nil {
 		if err2 := conn.Close(); err2 != nil {
-			return pc, errors.Wrap(err, err2.Error())
+			return pc, cmn.ErrorWrap(err, err2.Error())
 		}
 		return pc, err
 	}
@@ -128,7 +125,7 @@ func newOutboundPeerConn(addr *NetAddress, config *PeerConfig, persistent bool,
 	// ensure dialed ID matches connection ID
 	if config.AuthEnc && addr.ID != pc.ID() {
 		if err2 := conn.Close(); err2 != nil {
-			return pc, errors.Wrap(err, err2.Error())
+			return pc, cmn.ErrorWrap(err, err2.Error())
 		}
 		return pc, ErrSwitchAuthenticationFailure{addr, pc.ID()}
 	}
@@ -157,13 +154,13 @@ func newPeerConn(rawConn net.Conn,
 	if config.AuthEnc {
 		// Set deadline for secret handshake
 		if err := conn.SetDeadline(time.Now().Add(config.HandshakeTimeout * time.Second)); err != nil {
-			return pc, errors.Wrap(err, "Error setting deadline while encrypting connection")
+			return pc, cmn.ErrorWrap(err, "Error setting deadline while encrypting connection")
 		}
 
 		// Encrypt connection
 		conn, err = tmconn.MakeSecretConnection(conn, ourNodePrivKey)
 		if err != nil {
-			return pc, errors.Wrap(err, "Error creating peer")
+			return pc, cmn.ErrorWrap(err, "Error creating peer")
 		}
 	}
 
@@ -228,9 +225,9 @@ func (p *peer) Status() tmconn.ConnectionStatus {
 	return p.mconn.Status()
 }
 
-// Send msg to the channel identified by chID byte. Returns false if the send
-// queue is full after timeout, specified by MConnection.
-func (p *peer) Send(chID byte, msg interface{}) bool {
+// Send msg bytes to the channel identified by chID byte. Returns false if the
+// send queue is full after timeout, specified by MConnection.
+func (p *peer) Send(chID byte, msgBytes []byte) bool {
 	if !p.IsRunning() {
 		// see Switch#Broadcast, where we fetch the list of peers and loop over
 		// them - while we're looping, one peer may be removed and stopped.
@@ -238,18 +235,18 @@ func (p *peer) Send(chID byte, msg interface{}) bool {
 	} else if !p.hasChannel(chID) {
 		return false
 	}
-	return p.mconn.Send(chID, msg)
+	return p.mconn.Send(chID, msgBytes)
 }
 
-// TrySend msg to the channel identified by chID byte. Immediately returns
+// TrySend msg bytes to the channel identified by chID byte. Immediately returns
 // false if the send queue is full.
-func (p *peer) TrySend(chID byte, msg interface{}) bool {
+func (p *peer) TrySend(chID byte, msgBytes []byte) bool {
 	if !p.IsRunning() {
 		return false
 	} else if !p.hasChannel(chID) {
 		return false
 	}
-	return p.mconn.TrySend(chID, msg)
+	return p.mconn.TrySend(chID, msgBytes)
 }
 
 // Get the data for a given key.
@@ -290,30 +287,26 @@ func (pc *peerConn) CloseConn() {
 func (pc *peerConn) HandshakeTimeout(ourNodeInfo NodeInfo, timeout time.Duration) (peerNodeInfo NodeInfo, err error) {
 	// Set deadline for handshake so we don't block forever on conn.ReadFull
 	if err := pc.conn.SetDeadline(time.Now().Add(timeout)); err != nil {
-		return peerNodeInfo, errors.Wrap(err, "Error setting deadline")
+		return peerNodeInfo, cmn.ErrorWrap(err, "Error setting deadline")
 	}
 
-	var err1 error
-	var err2 error
-	cmn.Parallel(
-		func() {
-			var n int
-			wire.WriteBinary(&ourNodeInfo, pc.conn, &n, &err1)
+	var trs, _ = cmn.Parallel(
+		func(_ int) (val interface{}, err error, abort bool) {
+			_, err = cdc.MarshalBinaryWriter(pc.conn, ourNodeInfo)
+			return
 		},
-		func() {
-			var n int
-			wire.ReadBinary(&peerNodeInfo, pc.conn, MaxNodeInfoSize(), &n, &err2)
-		})
-	if err1 != nil {
-		return peerNodeInfo, errors.Wrap(err1, "Error during handshake/write")
-	}
-	if err2 != nil {
-		return peerNodeInfo, errors.Wrap(err2, "Error during handshake/read")
+		func(_ int) (val interface{}, err error, abort bool) {
+			_, err = cdc.UnmarshalBinaryReader(pc.conn, &peerNodeInfo, int64(MaxNodeInfoSize()))
+			return
+		},
+	)
+	if err := trs.FirstError(); err != nil {
+		return peerNodeInfo, cmn.ErrorWrap(err, "Error during handshake")
 	}
 
 	// Remove deadline
 	if err := pc.conn.SetDeadline(time.Time{}); err != nil {
-		return peerNodeInfo, errors.Wrap(err, "Error removing deadline")
+		return peerNodeInfo, cmn.ErrorWrap(err, "Error removing deadline")
 	}
 
 	return peerNodeInfo, nil