This is more flexible since it allows callers to perform efficient lookups on the result.
182 lines
5.0 KiB
Go
182 lines
5.0 KiB
Go
package router
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
type Routes struct {
|
|
sync.RWMutex
|
|
ourself *Peer
|
|
peers *Peers
|
|
unicast map[PeerName]PeerName
|
|
unicastAll map[PeerName]PeerName // [1]
|
|
broadcast map[PeerName][]PeerName
|
|
broadcastAll map[PeerName][]PeerName // [1]
|
|
recalculate chan<- *struct{}
|
|
// [1] based on *all* connections, not just established &
|
|
// symmetric ones
|
|
}
|
|
|
|
func NewRoutes(ourself *Peer, peers *Peers) *Routes {
|
|
routes := &Routes{
|
|
ourself: ourself,
|
|
peers: peers,
|
|
unicast: make(map[PeerName]PeerName),
|
|
unicastAll: make(map[PeerName]PeerName),
|
|
broadcast: make(map[PeerName][]PeerName),
|
|
broadcastAll: make(map[PeerName][]PeerName)}
|
|
routes.unicast[ourself.Name] = UnknownPeerName
|
|
routes.unicastAll[ourself.Name] = UnknownPeerName
|
|
routes.broadcast[ourself.Name] = []PeerName{}
|
|
routes.broadcastAll[ourself.Name] = []PeerName{}
|
|
return routes
|
|
}
|
|
|
|
func (routes *Routes) Start() {
|
|
recalculate := make(chan *struct{}, 1)
|
|
routes.recalculate = recalculate
|
|
go routes.run(recalculate)
|
|
}
|
|
|
|
func (routes *Routes) Unicast(name PeerName) (PeerName, bool) {
|
|
routes.RLock()
|
|
defer routes.RUnlock()
|
|
hop, found := routes.unicast[name]
|
|
return hop, found
|
|
}
|
|
|
|
func (routes *Routes) UnicastAll(name PeerName) (PeerName, bool) {
|
|
routes.RLock()
|
|
defer routes.RUnlock()
|
|
hop, found := routes.unicastAll[name]
|
|
return hop, found
|
|
}
|
|
|
|
func (routes *Routes) Broadcast(name PeerName) []PeerName {
|
|
routes.RLock()
|
|
defer routes.RUnlock()
|
|
hops, found := routes.broadcast[name]
|
|
if !found {
|
|
return []PeerName{}
|
|
}
|
|
return hops
|
|
}
|
|
|
|
func (routes *Routes) BroadcastAll(name PeerName) []PeerName {
|
|
routes.RLock()
|
|
defer routes.RUnlock()
|
|
hops, found := routes.broadcastAll[name]
|
|
if !found {
|
|
return []PeerName{}
|
|
}
|
|
return hops
|
|
}
|
|
|
|
func (routes *Routes) String() string {
|
|
var buf bytes.Buffer
|
|
routes.RLock()
|
|
defer routes.RUnlock()
|
|
fmt.Fprintln(&buf, "unicast:")
|
|
for name, hop := range routes.unicast {
|
|
fmt.Fprintf(&buf, "%s -> %s\n", name, hop)
|
|
}
|
|
fmt.Fprintln(&buf, "broadcast:")
|
|
for name, hops := range routes.broadcast {
|
|
fmt.Fprintf(&buf, "%s -> %v\n", name, hops)
|
|
}
|
|
// We don't include the 'all' routes here since they are of
|
|
// limited utility in troubleshooting
|
|
return buf.String()
|
|
}
|
|
|
|
func (routes *Routes) Recalculate() {
|
|
select {
|
|
case routes.recalculate <- nil:
|
|
default:
|
|
}
|
|
}
|
|
|
|
func (routes *Routes) run(recalculate <-chan *struct{}) {
|
|
for {
|
|
<-recalculate
|
|
routes.calculate()
|
|
}
|
|
}
|
|
|
|
func (routes *Routes) calculate() {
|
|
var (
|
|
unicast = routes.calculateUnicast(true)
|
|
unicastAll = routes.calculateUnicast(false)
|
|
broadcast = routes.calculateBroadcast(true)
|
|
broadcastAll = routes.calculateBroadcast(false)
|
|
)
|
|
routes.Lock()
|
|
routes.unicast = unicast
|
|
routes.unicastAll = unicastAll
|
|
routes.broadcast = broadcast
|
|
routes.broadcastAll = broadcastAll
|
|
routes.Unlock()
|
|
}
|
|
|
|
// Calculate all the routes for the question: if *we* want to send a
|
|
// packet to Peer X, what is the next hop?
|
|
//
|
|
// When we sniff a packet, we determine the destination peer
|
|
// ourself. Consequently, we can relay the packet via any
|
|
// arbitrary peers - the intermediate peers do not have to have
|
|
// any knowledge of the MAC address at all. Thus there's no need
|
|
// to exchange knowledge of MAC addresses, nor any constraints on
|
|
// the routes that we construct.
|
|
func (routes *Routes) calculateUnicast(establishedAndSymmetric bool) map[PeerName]PeerName {
|
|
_, unicast := routes.ourself.Routes(nil, establishedAndSymmetric)
|
|
return unicast
|
|
}
|
|
|
|
// Calculate all the routes for the question: if we receive a
|
|
// broadcast originally from Peer X, which peers should we pass the
|
|
// frames on to?
|
|
//
|
|
// When the topology is stable, and thus all peers perform route
|
|
// calculations based on the same data, the algorithm ensures that
|
|
// broadcasts reach every peer exactly once.
|
|
//
|
|
// This is largely due to properties of the Peer.Routes algorithm. In
|
|
// particular:
|
|
//
|
|
// ForAll X,Y,Z in Peers.
|
|
// X.Routes(Y) <= X.Routes(Z) \/
|
|
// X.Routes(Z) <= X.Routes(Y)
|
|
// ForAll X,Y,Z in Peers.
|
|
// Y =/= Z /\ X.Routes(Y) <= X.Routes(Z) =>
|
|
// X.Routes(Y) u [P | Y.HasSymmetricConnectionTo(P)] <= X.Routes(Z)
|
|
// where <= is the subset relationship on keys of the returned map.
|
|
func (routes *Routes) calculateBroadcast(establishedAndSymmetric bool) map[PeerName][]PeerName {
|
|
broadcast := make(map[PeerName][]PeerName)
|
|
ourself := routes.ourself
|
|
|
|
routes.peers.ForEach(func(peer *Peer) {
|
|
hops := []PeerName{}
|
|
if found, reached := peer.Routes(ourself, establishedAndSymmetric); found {
|
|
// This is rather similar to the inner loop on
|
|
// peer.Routes(...); the main difference is in the
|
|
// locking.
|
|
for conn := range ourself.Connections() {
|
|
if establishedAndSymmetric && !conn.Established() {
|
|
continue
|
|
}
|
|
remoteName := conn.Remote().Name
|
|
if _, found := reached[remoteName]; found {
|
|
continue
|
|
}
|
|
if remoteConn, found := conn.Remote().ConnectionTo(ourself.Name); !establishedAndSymmetric || (found && remoteConn.Established()) {
|
|
hops = append(hops, remoteName)
|
|
}
|
|
}
|
|
}
|
|
broadcast[peer.Name] = hops
|
|
})
|
|
return broadcast
|
|
}
|