compiles after NewBroadcast change

p2p/peer.go

@@ -39,9 +39,6 @@ type Peer interface {
 	NewSend(Envelope) bool
 	NewTrySend(Envelope) bool
 
-	Send(byte, []byte) bool
-	TrySend(byte, []byte) bool
-
 	Set(string, interface{})
 	Get(string) interface{}
 

p2p/switch.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/cmap"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/rand"
 	"github.com/tendermint/tendermint/libs/service"
 	"github.com/tendermint/tendermint/p2p/conn"
@@ -261,6 +260,7 @@ func (sw *Switch) OnStop() {
 // closed once msg bytes are sent to all peers (or time out).
 //
 // NOTE: Broadcast uses goroutines, so order of broadcast may not be preserved.
+/*
 func (sw *Switch) Broadcast(chID byte, msgBytes []byte) chan bool {
 	sw.Logger.Debug("Broadcast", "channel", chID, "msgBytes", log.NewLazySprintf("%X", msgBytes))
 
@@ -284,6 +284,7 @@ func (sw *Switch) Broadcast(chID byte, msgBytes []byte) chan bool {
 
 	return successChan
 }
+*/
 
 // NewBroadcast runs a go routine for each attempted send, which will block trying
 // to send for defaultSendTimeoutSeconds. Returns a channel which receives

p2p/switch_test.go

@@ -14,6 +14,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang/protobuf/proto"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -23,6 +24,8 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
 	"github.com/tendermint/tendermint/p2p/conn"
+	"github.com/tendermint/tendermint/proto/tendermint/p2p"
+	p2pproto "github.com/tendermint/tendermint/proto/tendermint/p2p"
 )
 
 var (
@@ -135,24 +138,59 @@ func TestSwitches(t *testing.T) {
 	}
 
 	// Lets send some messages
-	ch0Msg := []byte("channel zero")
-	ch1Msg := []byte("channel foo")
-	ch2Msg := []byte("channel bar")
-
-	s1.Broadcast(byte(0x00), ch0Msg)
-	s1.Broadcast(byte(0x01), ch1Msg)
-	s1.Broadcast(byte(0x02), ch2Msg)
+	ch0Msg := &p2pproto.Message{
+		Sum: &p2pproto.Message_PexAddrs{
+			PexAddrs: &p2pproto.PexAddrs{
+				Addrs: []p2p.NetAddress{
+					{
+						ID: "0",
+					},
+				},
+			},
+		},
+	}
+	ch1Msg := &p2pproto.Message{
+		Sum: &p2pproto.Message_PexAddrs{
+			PexAddrs: &p2pproto.PexAddrs{
+				Addrs: []p2p.NetAddress{
+					{
+						ID: "1",
+					},
+				},
+			},
+		},
+	}
+	ch2Msg := &p2pproto.Message{
+		Sum: &p2pproto.Message_PexAddrs{
+			PexAddrs: &p2pproto.PexAddrs{
+				Addrs: []p2p.NetAddress{
+					{
+						ID: "2",
+					},
+				},
+			},
+		},
+	}
+	s1.NewBroadcast(Envelope{ChannelID: byte(0x00), Message: ch0Msg})
+	s1.NewBroadcast(Envelope{ChannelID: byte(0x01), Message: ch1Msg})
+	s1.NewBroadcast(Envelope{ChannelID: byte(0x02), Message: ch2Msg})
 
+	msgBytes, err := proto.Marshal(ch0Msg)
+	require.NoError(t, err)
 	assertMsgReceivedWithTimeout(t,
-		ch0Msg,
+		msgBytes,
 		byte(0x00),
 		s2.Reactor("foo").(*TestReactor), 10*time.Millisecond, 5*time.Second)
+	msgBytes, err = proto.Marshal(ch1Msg)
+	require.NoError(t, err)
 	assertMsgReceivedWithTimeout(t,
-		ch1Msg,
+		msgBytes,
 		byte(0x01),
 		s2.Reactor("foo").(*TestReactor), 10*time.Millisecond, 5*time.Second)
+	msgBytes, err = proto.Marshal(ch2Msg)
+	require.NoError(t, err)
 	assertMsgReceivedWithTimeout(t,
-		ch2Msg,
+		msgBytes,
 		byte(0x02),
 		s2.Reactor("bar").(*TestReactor), 10*time.Millisecond, 5*time.Second)
 }
@@ -827,7 +865,7 @@ func BenchmarkSwitchBroadcast(b *testing.B) {
 	// Send random message from foo channel to another
 	for i := 0; i < b.N; i++ {
 		chID := byte(i % 4)
-		successChan := s1.Broadcast(chID, []byte("test data"))
+		successChan := s1.NewBroadcast(Envelope{ChannelID: chID})
 		for s := range successChan {
 			if s {
 				numSuccess++