all reactors have receive with empty new receive call

blockchain/v1/reactor.go

@@ -306,7 +306,9 @@ func (bcR *BlockchainReactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (bcR *BlockchainReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (bcR *BlockchainReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	bcR.NewReceive(p2p.Envelope{})
+}
 
 // processBlocksRoutine processes blocks until signlaed to stop over the stopProcessing channel
 func (bcR *BlockchainReactor) processBlocksRoutine(stopProcessing chan struct{}) {

blockchain/v2/reactor.go

@@ -513,7 +513,9 @@ func (r *BlockchainReactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (r *BlockchainReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (r *BlockchainReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	r.NewReceive(p2p.Envelope{})
+}
 
 // AddPeer implements Reactor interface
 func (r *BlockchainReactor) AddPeer(peer p2p.Peer) {

blocksync/reactor.go

@@ -233,7 +233,9 @@ func (bcR *Reactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (bcR *BlockchainReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (bcR *BlockchainReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	bcR.NewReceive(p2p.Envelope{})
+}
 
 // Handle messages from the poolReactor telling the reactor what to do.
 // NOTE: Don't sleep in the FOR_LOOP or otherwise slow it down!

consensus/byzantine_test.go

@@ -602,7 +602,9 @@ func (br *ByzantineReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
 func (br *ByzantineReactor) NewReceive(e p2p.Envelope) {
 	br.reactor.NewReceive(e)
 }
-func (br *ByzantineReactor) Receive(chID byte, p p2p.Peer, m []byte) {
+func (br *ByzantineReactor) Receive(chID byte, p p2p.Peer, m []byte) 
+br.NewReceive(p2p.Envelope{})
+{
 	br.reactor.Receive(chID, p, m)
 }
 func (br *ByzantineReactor) InitPeer(peer p2p.Peer) p2p.Peer { return peer }

consensus/reactor.go

@@ -387,7 +387,9 @@ func (conR *Reactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (conR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (conR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	conR.NewReceive(p2p.Envelope{})
+}
 
 // SetEventBus sets event bus.
 func (conR *Reactor) SetEventBus(b *types.EventBus) {

evidence/reactor.go

@@ -92,7 +92,9 @@ func (evR *Reactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (evR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (evR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	evR.NewReceive(p2p.Envelope{})
+}
 
 // SetEventBus implements events.Eventable.
 func (evR *Reactor) SetEventBus(b *types.EventBus) {

mempool/v1/reactor.go

@@ -187,7 +187,9 @@ func (memR *Reactor) NewReceive(e p2p.Envelope) {
 	// broadcasting happens from go routines per peer
 }
 
-func (memR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (memR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	memR.NewReceive(p2p.Envelope{})
+}
 
 // PeerState describes the state of a peer.
 type PeerState interface {

p2p/base_reactor.go

@@ -82,7 +82,5 @@ func (*BaseReactor) GetChannels() []*conn.ChannelDescriptor        { return nil
 func (*BaseReactor) AddPeer(peer Peer)                             {}
 func (*BaseReactor) RemovePeer(peer Peer, reason interface{})      {}
 func (*BaseReactor) NewReceive(e Envelope)                         {}
-
-func (*BaseReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte)                         {}}
 func (*BaseReactor) Receive(chID byte, peer Peer, msgBytes []byte) {}
 func (*BaseReactor) InitPeer(peer Peer) Peer                       { return peer }

p2p/mock/reactor.go

@@ -19,9 +19,8 @@ func NewReactor() *Reactor {
 	return r
 }
 
-func (r *Reactor) GetChannels() []*conn.ChannelDescriptor       { return r.Channels }
-func (r *Reactor) AddPeer(peer p2p.Peer)                        {}
-func (r *Reactor) RemovePeer(peer p2p.Peer, reason interface{}) {}
-func (r *Reactor) NewReceive(e p2p.Envelope)                    {}
-
-func (r *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte)                    {}}
+func (r *Reactor) GetChannels() []*conn.ChannelDescriptor            { return r.Channels }
+func (r *Reactor) AddPeer(peer p2p.Peer)                             {}
+func (r *Reactor) RemovePeer(peer p2p.Peer, reason interface{})      {}
+func (r *Reactor) NewReceive(e p2p.Envelope)                         {}
+func (r *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}

p2p/pex/pex_reactor.go

@@ -298,7 +298,9 @@ func (r *Reactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (r *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (r *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	r.NewReceive(p2p.Envelope{})
+}
 
 // enforces a minimum amount of time between requests
 func (r *Reactor) receiveRequest(src Peer) error {

p2p/switch_test.go

@@ -82,7 +82,9 @@ func (tr *TestReactor) NewReceive(e Envelope) {
 	}
 }
 
-func (tr *TestReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (tr *TestReactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	tr.NewReceive(p2p.Envelope{})
+}
 
 func (tr *TestReactor) getMsgs(chID byte) []PeerMessage {
 	tr.mtx.Lock()

statesync/reactor.go

@@ -223,7 +223,9 @@ func (r *Reactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (r *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (r *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	r.NewReceive(p2p.Envelope{})
+}
 
 // recentSnapshots fetches the n most recent snapshots from the app
 func (r *Reactor) recentSnapshots(n uint32) ([]*snapshot, error) {

test/maverick/consensus/reactor.go

@@ -387,7 +387,9 @@ func (conR *Reactor) NewReceive(e p2p.Envelope) {
 	}
 }
 
-func (conR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
+func (conR *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {
+	conR.NewReceive(p2p.Envelope{})
+}
 
 // SetEventBus sets event bus.
 func (conR *Reactor) SetEventBus(b *types.EventBus) {