make GossipData immutable

The same piece of GossipData can be shared and subject to different
Merge operations. We either need to copy the data when we share it, or
create copies on modification, i.e. copy-on-write.

We choose the latter, since it is more efficient and there is just one
mutating operation.

Fixes #1697.

ipam/allocator.go

@@ -478,8 +478,8 @@ type ipamGossipData struct {
 	alloc *Allocator
 }
 
-func (d *ipamGossipData) Merge(other mesh.GossipData) {
+func (d *ipamGossipData) Merge(other mesh.GossipData) mesh.GossipData {
-	// no-op
+	return d // no-op
 }
 
 func (d *ipamGossipData) Encode() [][]byte {

mesh/gossip.go

@@ -6,7 +6,7 @@ import (
 
 type GossipData interface {
 	Encode() [][]byte
-	Merge(GossipData)
+	Merge(GossipData) GossipData
 }
 
 type Gossip interface {
@@ -79,8 +79,7 @@ func (sender *GossipSender) Send(data GossipData) {
 	// NB: this must not be invoked concurrently
 	select {
 	case pending := <-sender.cell:
-		pending.Merge(data)
+		sender.cell <- pending.Merge(data)
-		sender.cell <- pending
 	default:
 		sender.cell <- data
 	}

mesh/router.go

@@ -127,17 +127,19 @@ func (router *Router) BroadcastTopologyUpdate(update []*Peer) {
 	for _, p := range update {
 		names[p.Name] = void
 	}
-
+	router.TopologyGossip.GossipBroadcast(
-	router.TopologyGossip.GossipBroadcast(&TopologyGossipData{
+		&TopologyGossipData{peers: router.Peers, update: names})
-		peers:  router.Peers,
-		update: names,
-	})
 }
 
-func (d *TopologyGossipData) Merge(other GossipData) {
+func (d *TopologyGossipData) Merge(other GossipData) GossipData {
-	for name := range other.(*TopologyGossipData).update {
+	names := make(PeerNameSet)
-		d.update[name] = void
+	for name := range d.update {
+		names[name] = void
 	}
+	for name := range other.(*TopologyGossipData).update {
+		names[name] = void
+	}
+	return &TopologyGossipData{peers: d.peers, update: names}
 }
 
 func (d *TopologyGossipData) Encode() [][]byte {

mesh/surrogate_gossiper.go

@@ -12,8 +12,12 @@ func (d *SurrogateGossipData) Encode() [][]byte {
 	return d.messages
 }
 
-func (d *SurrogateGossipData) Merge(other GossipData) {
+func (d *SurrogateGossipData) Merge(other GossipData) GossipData {
-	d.messages = append(d.messages, other.(*SurrogateGossipData).messages...)
+	o := other.(*SurrogateGossipData)
+	messages := make([][]byte, 0, len(d.messages)+len(o.messages))
+	messages = append(messages, d.messages...)
+	messages = append(messages, o.messages...)
+	return &SurrogateGossipData{messages: messages}
 }
 
 // SurrogateGossiper ignores unicasts and relays broadcasts and gossips.

nameserver/entry.go

@@ -245,12 +245,18 @@ type GossipData struct {
 	Entries
 }
 
-func (g *GossipData) Merge(o mesh.GossipData) {
+func (g *GossipData) Merge(o mesh.GossipData) mesh.GossipData {
 	other := o.(*GossipData)
-	g.Entries.merge(other.Entries)
+	gossip := &GossipData{
-	if g.Timestamp < other.Timestamp {
+		Entries:   make(Entries, len(g.Entries)),
-		g.Timestamp = other.Timestamp
+		Timestamp: g.Timestamp,
 	}
+	copy(gossip.Entries, g.Entries)
+	gossip.Entries.merge(other.Entries)
+	if gossip.Timestamp < other.Timestamp {
+		gossip.Timestamp = other.Timestamp
+	}
+	return gossip
 }
 
 func (g *GossipData) Decode(msg []byte) error {

nameserver/entry_test.go

@@ -117,7 +117,7 @@ func TestGossipDataMerge(t *testing.T) {
 	g1 := GossipData{Entries: makeEntries("AcDf")}
 	g2 := GossipData{Entries: makeEntries("BEf")}
 
-	g1.Merge(&g2)
+	g3 := g1.Merge(&g2).(*GossipData)
 
-	require.Equal(t, GossipData{Entries: makeEntries("ABcDEf")}, g1)
+	require.Equal(t, GossipData{Entries: makeEntries("ABcDEf")}, *g3)
 }