refactor: give Peers knowledge of Ourself.Peer and MacCache

so their use (when applying updates and performing gc) is opaque

router/connection.go

@@ -495,7 +495,7 @@ func (conn *LocalConnection) receiveTCP(decoder *gob.Decoder, usingPassword bool
 			//    receiver's version are updated
 			conn.SendTCP(Concat(ProtocolUpdateByte, conn.Router.Peers.EncodeAllPeers()))
 		} else if msg[0] == ProtocolUpdate {
-			newUpdate, err := conn.Router.Peers.ApplyUpdate(msg[1:], conn.Router.Ourself.Peer, conn.Router.Macs)
+			newUpdate, err := conn.Router.Peers.ApplyUpdate(msg[1:])
 			if _, ok := err.(UnknownPeersError); err != nil && ok {
 				// That update contained a peer we didn't know about;
 				// request full update

router/peer.go

@@ -362,7 +362,7 @@ func (peer *LocalPeer) handleDeleteConnection(conn *LocalConnection) {
 	}
 	// Must do garbage collection first to ensure we don't send out an
 	// update with unreachable peers (can cause looping)
-	peer.Router.Peers.GarbageCollect(peer.Router.Ourself.Peer, peer.Router.Macs)
+	peer.Router.Peers.GarbageCollect()
 	if broadcast {
 		peer.broadcastPeerUpdate()
 	}

router/peers.go

@@ -10,12 +10,18 @@ import (
 
 type Peers struct {
 	sync.RWMutex
-	table map[PeerName]*Peer
-	onGC  func(*Peer)
+	ourself *Peer
+	macs    *MacCache
+	table   map[PeerName]*Peer
+	onGC    func(*Peer)
 }
 
-func NewPeers(onGC func(*Peer)) *Peers {
-	return &Peers{table: make(map[PeerName]*Peer), onGC: onGC}
+func NewPeers(ourself *Peer, macs *MacCache, onGC func(*Peer)) *Peers {
+	return &Peers{
+		ourself: ourself,
+		macs:    macs,
+		table:   make(map[PeerName]*Peer),
+		onGC:    onGC}
 }
 
 func (peers *Peers) FetchWithDefault(peer *Peer) *Peer {
@@ -51,7 +57,7 @@ func (peers *Peers) ForEach(fun func(PeerName, *Peer)) {
 	}
 }
 
-func (peers *Peers) ApplyUpdate(update []byte, ourself *Peer, macs *MacCache) ([]byte, error) {
+func (peers *Peers) ApplyUpdate(update []byte) ([]byte, error) {
 	peers.Lock()
 
 	newPeers, decodedUpdate, decodedConns, err := peers.decodeUpdate(update)
@@ -68,9 +74,9 @@ func (peers *Peers) ApplyUpdate(update []byte, ourself *Peer, macs *MacCache) ([
 	}
 
 	// Now apply the updates
-	newUpdate := peers.applyUpdate(decodedUpdate, decodedConns, ourself)
+	newUpdate := peers.applyUpdate(decodedUpdate, decodedConns)
 
-	for _, peerRemoved := range peers.garbageCollect(ourself, macs) {
+	for _, peerRemoved := range peers.garbageCollect() {
 		delete(newUpdate, peerRemoved.Name)
 	}
 
@@ -95,10 +101,10 @@ func EncodePeers(peers ...*Peer) []byte {
 	return buf.Bytes()
 }
 
-func (peers *Peers) GarbageCollect(ourself *Peer, macs *MacCache) []*Peer {
+func (peers *Peers) GarbageCollect() []*Peer {
 	peers.Lock()
 	defer peers.Unlock()
-	return peers.garbageCollect(ourself, macs)
+	return peers.garbageCollect()
 }
 
 func (peers *Peers) String() string {
@@ -124,14 +130,14 @@ func (peers *Peers) fetchAlias(peer *Peer) (*Peer, bool) {
 	return nil, false
 }
 
-func (peers *Peers) garbageCollect(ourself *Peer, macs *MacCache) []*Peer {
+func (peers *Peers) garbageCollect() []*Peer {
 	removed := []*Peer{}
 	for name, peer := range peers.table {
-		found, _ := ourself.Routes(peer, false)
+		found, _ := peers.ourself.Routes(peer, false)
 		if !found && !peer.IsLocallyReferenced() {
 			peers.onGC(peer)
 			delete(peers.table, name)
-			macs.Delete(peer)
+			peers.macs.Delete(peer)
 			removed = append(removed, peer)
 		}
 	}
@@ -199,7 +205,7 @@ func (peers *Peers) decodeUpdate(update []byte) (newPeers map[PeerName]*Peer, de
 	return
 }
 
-func (peers *Peers) applyUpdate(decodedUpdate []*Peer, decodedConns [][]byte, ourself *Peer) map[PeerName]*Peer {
+func (peers *Peers) applyUpdate(decodedUpdate []*Peer, decodedConns [][]byte) map[PeerName]*Peer {
 	newUpdate := make(map[PeerName]*Peer)
 	for idx, newPeer := range decodedUpdate {
 		connsBuf := decodedConns[idx]
@@ -216,7 +222,7 @@ func (peers *Peers) applyUpdate(decodedUpdate []*Peer, decodedConns [][]byte, ou
 				// change.
 				newUpdate[name] = peer
 				continue
-			} else if peer == ourself {
+			} else if peer == peers.ourself {
 				// nobody but us updates us
 				continue
 			} else if peer.Version() == newPeer.Version() {

router/router.go

@@ -27,7 +27,6 @@ func NewRouter(iface *net.Interface, name PeerName, password []byte, connLimit i
 	router := &Router{
 		Iface:     iface,
 		Macs:      NewMacCache(macMaxAge, onMacExpiry),
-		Peers:     NewPeers(onPeerGC),
 		ConnLimit: connLimit,
 		BufSz:     bufSz,
 		LogFrame:  logFrame}
@@ -35,6 +34,7 @@ func NewRouter(iface *net.Interface, name PeerName, password []byte, connLimit i
 		router.Password = &password
 	}
 	router.Ourself = StartLocalPeer(name, router)
+	router.Peers = NewPeers(router.Ourself.Peer, router.Macs, onPeerGC)
 	router.Peers.FetchWithDefault(router.Ourself.Peer)
 	log.Println("Our name is", router.Ourself.Name)