From 91ed22a9536762d0a77f4dc7924c895bdab2d0e1 Mon Sep 17 00:00:00 2001
From: Matthias Radestock <matthias.radestock@gmail.com>
Date: Sat, 4 Apr 2015 20:36:48 +0100
Subject: [PATCH] refactor(ish): generalise an abstraction
 LocalPeer.NextBroadcastHops -> ConnectionsTo thus separating the computation
 of who we want to connect to from obtaining the associated Connections

---
 router/gossip.go     | 14 +++++++-------
 router/local_peer.go | 24 ++++++++++++------------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/router/gossip.go b/router/gossip.go
index 4e9e060d..0cd17589 100644
--- a/router/gossip.go
+++ b/router/gossip.go
@@ -230,13 +230,13 @@ func (c *GossipChannel) relayGossipUnicast(dstPeerName PeerName, msg []byte) err
 }
 
 func (c *GossipChannel) relayGossipBroadcast(srcName PeerName, msg []byte) error {
-	if srcPeer, found := c.ourself.Router.Peers.Fetch(srcName); !found {
-		c.log("unable to relay broadcast from unknown peer", srcName)
-	} else {
-		protocolMsg := ProtocolMsg{ProtocolGossipBroadcast, msg}
-		for _, conn := range c.ourself.NextBroadcastHops(srcPeer) {
-			conn.SendProtocolMsg(protocolMsg)
-		}
+	nextHops := c.ourself.Router.Routes.Broadcast(srcName)
+	if len(nextHops) == 0 {
+		return nil
+	}
+	protocolMsg := ProtocolMsg{ProtocolGossipBroadcast, msg}
+	for _, conn := range c.ourself.ConnectionsTo(nextHops) {
+		conn.(ProtocolSender).SendProtocolMsg(protocolMsg)
 	}
 	return nil
 }
diff --git a/router/local_peer.go b/router/local_peer.go
index d28f8f35..7437337f 100644
--- a/router/local_peer.go
+++ b/router/local_peer.go
@@ -55,8 +55,12 @@ func (peer *LocalPeer) Relay(srcPeer, dstPeer *Peer, df bool, frame []byte, dec
 }
 
 func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) {
-	for _, conn := range peer.NextBroadcastHops(srcPeer) {
-		err := conn.Forward(df, &ForwardedFrame{
+	nextHops := peer.Router.Routes.Broadcast(srcPeer.Name)
+	if len(nextHops) == 0 {
+		return
+	}
+	for _, conn := range peer.ConnectionsTo(nextHops) {
+		err := conn.(*LocalConnection).Forward(df, &ForwardedFrame{
 			srcPeer: srcPeer,
 			dstPeer: conn.Remote(),
 			frame:   frame},
@@ -71,22 +75,18 @@ func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, df bool, frame []byte, dec
 	}
 }
 
-func (peer *LocalPeer) NextBroadcastHops(srcPeer *Peer) []*LocalConnection {
-	nextHops := peer.Router.Routes.Broadcast(srcPeer.Name)
-	if len(nextHops) == 0 {
-		return nil
-	}
-	nextConns := make([]*LocalConnection, 0, len(nextHops))
+func (peer *LocalPeer) ConnectionsTo(names []PeerName) []Connection {
+	conns := make([]Connection, 0, len(names))
 	peer.RLock()
 	defer peer.RUnlock()
-	for _, hopName := range nextHops {
-		conn, found := peer.connections[hopName]
+	for _, name := range names {
+		conn, found := peer.connections[name]
 		// Again, !found could just be due to a race.
 		if found {
-			nextConns = append(nextConns, conn.(*LocalConnection))
+			conns = append(conns, conn)
 		}
 	}
-	return nextConns
+	return conns
 }
 
 func (peer *LocalPeer) CreateConnection(peerAddr string, acceptNewPeer bool) error {