Merge branch 'awh-reduced_gob'

This commit is contained in:
Matthias Radestock committed 2015-05-05 22:10:38 +01:00
commit dfac7ea564
1 file changed
+50 -76
+50 -76
View File
@@ -25,6 +25,20 @@ type NameCollisionError struct {
type PeerNameSet map[PeerName]struct{} type PeerNameSet map[PeerName]struct{}
type PeerSummary struct {
NameByte []byte
NickName string
UID uint64
Version uint64
}
type ConnectionSummary struct {
NameByte []byte
RemoteTCPAddr string
Outbound bool
Established bool
}
func NewPeers(ourself *Peer, onGC func(*Peer)) *Peers { func NewPeers(ourself *Peer, onGC func(*Peer)) *Peers {
return &Peers{ return &Peers{
ourself: ourself, ourself: ourself,
@@ -180,27 +194,27 @@ func setFromPeersMap(peers map[PeerName]*Peer) PeerNameSet {
return names return names
} }
func (peers *Peers) decodeUpdate(update []byte) (newPeers map[PeerName]*Peer, decodedUpdate []*Peer, decodedConns [][]byte, err error) { func (peers *Peers) decodeUpdate(update []byte) (newPeers map[PeerName]*Peer, decodedUpdate []*Peer, decodedConns [][]ConnectionSummary, err error) {
newPeers = make(map[PeerName]*Peer) newPeers = make(map[PeerName]*Peer)
decodedUpdate = []*Peer{} decodedUpdate = []*Peer{}
decodedConns = [][]byte{} decodedConns = [][]ConnectionSummary{}
updateBuf := new(bytes.Buffer) updateBuf := new(bytes.Buffer)
updateBuf.Write(update) updateBuf.Write(update)
decoder := gob.NewDecoder(updateBuf) decoder := gob.NewDecoder(updateBuf)
for { for {
nameByte, nickName, uid, version, connsBuf, decErr := decodePeerNoConns(decoder) peerSummary, connSummaries, decErr := decodePeer(decoder)
if decErr == io.EOF { if decErr == io.EOF {
break break
} else if decErr != nil { } else if decErr != nil {
err = decErr err = decErr
return return
} }
name := PeerNameFromBin(nameByte) name := PeerNameFromBin(peerSummary.NameByte)
newPeer := NewPeer(name, nickName, uid, version) newPeer := NewPeer(name, peerSummary.NickName, peerSummary.UID, peerSummary.Version)
decodedUpdate = append(decodedUpdate, newPeer) decodedUpdate = append(decodedUpdate, newPeer)
decodedConns = append(decodedConns, connsBuf) decodedConns = append(decodedConns, connSummaries)
existingPeer, found := peers.table[name] existingPeer, found := peers.table[name]
if !found { if !found {
newPeers[name] = newPeer newPeers[name] = newPeer
@@ -210,33 +224,28 @@ func (peers *Peers) decodeUpdate(update []byte) (newPeers map[PeerName]*Peer, de
} }
} }
for _, connsBuf := range decodedConns { for _, connSummaries := range decodedConns {
decErr := connsIterator(connsBuf, func(remoteNameByte []byte, _ string, _, _ bool) { for _, connSummary := range connSummaries {
remoteName := PeerNameFromBin(remoteNameByte) remoteName := PeerNameFromBin(connSummary.NameByte)
if _, found := newPeers[remoteName]; found { if _, found := newPeers[remoteName]; found {
return continue
} }
if _, found := peers.table[remoteName]; found { if _, found := peers.table[remoteName]; found {
return continue
} }
// Update refers to a peer which we have no knowledge // Update refers to a peer which we have no knowledge
// of. Thus we can't apply the update. Abort. // of. Thus we can't apply the update. Abort.
err = UnknownPeerError{remoteName} err = UnknownPeerError{remoteName}
})
if decErr != nil && decErr != io.EOF {
err = decErr
}
if err != nil {
return return
} }
} }
return return
} }
func (peers *Peers) applyUpdate(decodedUpdate []*Peer, decodedConns [][]byte) map[PeerName]*Peer { func (peers *Peers) applyUpdate(decodedUpdate []*Peer, decodedConns [][]ConnectionSummary) map[PeerName]*Peer {
newUpdate := make(map[PeerName]*Peer) newUpdate := make(map[PeerName]*Peer)
for idx, newPeer := range decodedUpdate { for idx, newPeer := range decodedUpdate {
connsBuf := decodedConns[idx] connSummaries := decodedConns[idx]
name := newPeer.Name name := newPeer.Name
// guaranteed to find peer in the peers.table // guaranteed to find peer in the peers.table
peer := peers.table[name] peer := peers.table[name]
@@ -257,7 +266,7 @@ func (peers *Peers) applyUpdate(decodedUpdate []*Peer, decodedConns [][]byte) ma
// for an update would be someone else calling // for an update would be someone else calling
// router.Peers.ApplyUpdate. But ApplyUpdate takes the Lock on // router.Peers.ApplyUpdate. But ApplyUpdate takes the Lock on
// the router.Peers, so there can be no race here. // the router.Peers, so there can be no race here.
conns := readConnsMap(peer, connsBuf, peers.table) conns := makeConnsMap(peer, connSummaries, peers.table)
peer.SetVersionAndConnections(newPeer.Version(), conns) peer.SetVersionAndConnections(newPeer.Version(), conns)
newUpdate[name] = peer newUpdate[name] = peer
} }
@@ -268,78 +277,43 @@ func (peer *Peer) encode(enc *gob.Encoder) {
peer.RLock() peer.RLock()
defer peer.RUnlock() defer peer.RUnlock()
checkFatal(enc.Encode(peer.NameByte)) checkFatal(enc.Encode(PeerSummary{
checkFatal(enc.Encode(peer.NickName)) peer.NameByte,
checkFatal(enc.Encode(peer.UID)) peer.NickName,
checkFatal(enc.Encode(peer.version)) peer.UID,
peer.version}))
connsBuf := new(bytes.Buffer) connSummaries := []ConnectionSummary{}
connsEnc := gob.NewEncoder(connsBuf)
for _, conn := range peer.connections { for _, conn := range peer.connections {
checkFatal(connsEnc.Encode(conn.Remote().NameByte)) connSummaries = append(connSummaries, ConnectionSummary{
checkFatal(connsEnc.Encode(conn.RemoteTCPAddr())) conn.Remote().NameByte,
checkFatal(connsEnc.Encode(conn.Outbound())) conn.RemoteTCPAddr(),
// DANGER holding rlock on peer, going to take rlock on conn conn.Outbound(),
checkFatal(connsEnc.Encode(conn.Established())) // DANGER holding rlock on peer, going to take rlock on conn
conn.Established(),
})
} }
checkFatal(enc.Encode(connsBuf.Bytes()))
checkFatal(enc.Encode(connSummaries))
} }
func decodePeerNoConns(dec *gob.Decoder) (nameByte []byte, nickName string, uid uint64, version uint64, conns []byte, err error) { func decodePeer(dec *gob.Decoder) (peerSummary PeerSummary, connSummaries []ConnectionSummary, err error) {
if err = dec.Decode(&nameByte); err != nil { if err = dec.Decode(&peerSummary); err != nil {
return return
} }
if err = dec.Decode(&nickName); err != nil { if err = dec.Decode(&connSummaries); err != nil {
return
}
if err = dec.Decode(&uid); err != nil {
return
}
if err = dec.Decode(&version); err != nil {
return
}
if err = dec.Decode(&conns); err != nil {
return return
} }
return return
} }
func connsIterator(input []byte, fun func([]byte, string, bool, bool)) error { func makeConnsMap(peer *Peer, connSummaries []ConnectionSummary, table map[PeerName]*Peer) map[PeerName]Connection {
buf := new(bytes.Buffer)
buf.Write(input)
dec := gob.NewDecoder(buf)
for {
var nameByte []byte
if err := dec.Decode(&nameByte); err != nil {
return err
}
var foundAt string
if err := dec.Decode(&foundAt); err != nil {
return err
}
var outbound bool
if err := dec.Decode(&outbound); err != nil {
return err
}
var established bool
if err := dec.Decode(&established); err != nil {
return err
}
fun(nameByte, foundAt, outbound, established)
}
}
func readConnsMap(peer *Peer, buf []byte, table map[PeerName]*Peer) map[PeerName]Connection {
conns := make(map[PeerName]Connection) conns := make(map[PeerName]Connection)
if err := connsIterator(buf, func(nameByte []byte, remoteTCPAddr string, outbound bool, established bool) { for _, connSummary := range connSummaries {
name := PeerNameFromBin(nameByte) name := PeerNameFromBin(connSummary.NameByte)
remotePeer := table[name] remotePeer := table[name]
conn := NewRemoteConnection(peer, remotePeer, remoteTCPAddr, outbound, established) conn := NewRemoteConnection(peer, remotePeer, connSummary.RemoteTCPAddr, connSummary.Outbound, connSummary.Established)
conns[name] = conn conns[name] = conn
}); err != io.EOF {
// this should never happen since we've already successfully
// decoded the same data in decodeUpdate
checkFatal(err)
} }
return conns return conns
} }