@@ -38,3 +38,4 @@ cmd/dnet/dnet

 libnetworkbuild.created

 test/networkDb/testMain

+test/networkDb/gossipdb

@@ -134,6 +134,8 @@ func (nDB *NetworkDB) sendTableEvent(event TableEvent_Type, nid string, tname st

 		TableName: tname,

 		Key:       key,

 		Value:     entry.value,

+		// The duration in second is a float that below would be truncated

+		ResidualReapTime: int32(entry.reapTime.Seconds()),

 	}

 	raw, err := encodeMessage(MessageTypeTableEvent, &tEvent)

@@ -349,11 +349,11 @@ func (nDB *NetworkDB) reapTableEntries() {

 		nid := params[1]

 		key := params[2]

-		if _, ok := nDB.indexes[byTable].Delete(fmt.Sprintf("/%s/%s/%s", tname, nid, key)); !ok {

+		okTable, okNetwork := nDB.deleteEntry(nid, tname, key)

+		if !okTable {

 			logrus.Errorf("Could not delete entry in table %s with network id %s and key %s as it does not exist", tname, nid, key)

 		}

-

-		if _, ok := nDB.indexes[byNetwork].Delete(fmt.Sprintf("/%s/%s/%s", nid, tname, key)); !ok {

+		if !okNetwork {

 			logrus.Errorf("Could not delete entry in network %s with table name %s and key %s as it does not exist", nid, tname, key)

 		}

 	}

@@ -406,8 +406,9 @@ func (nDB *NetworkDB) gossip() {

 		// Collect stats and print the queue info, note this code is here also to have a view of the queues empty

 		network.qMessagesSent += len(msgs)

 		if printStats {

-			logrus.Infof("NetworkDB stats - Queue net:%s qLen:%d netPeers:%d netMsg/s:%d",

-				nid, broadcastQ.NumQueued(), broadcastQ.NumNodes(), network.qMessagesSent/int((nDB.config.StatsPrintPeriod/time.Second)))

+			logrus.Infof("NetworkDB stats - net:%s Entries:%d Queue  qLen:%d netPeers:%d netMsg/s:%d",

+				nid, network.entriesNumber, broadcastQ.NumQueued(), broadcastQ.NumNodes(),

+				network.qMessagesSent/int((nDB.config.StatsPrintPeriod/time.Second)))

 			network.qMessagesSent = 0

 		}

@@ -572,6 +573,8 @@ func (nDB *NetworkDB) bulkSyncNode(networks []string, node string, unsolicited b

 				TableName: params[1],

 				Key:       params[2],

 				Value:     entry.value,

+				// The duration in second is a float that below would be truncated

+				ResidualReapTime: int32(entry.reapTime.Seconds()),

 			}

 			msg, err := encodeMessage(MessageTypeTableEvent, &tEvent)

@@ -1,9 +1,9 @@

 package networkdb

 import (

-	"fmt"

 	"net"

 	"strings"

+	"time"

 	"github.com/gogo/protobuf/proto"

 	"github.com/sirupsen/logrus"

@@ -198,8 +198,7 @@ func (nDB *NetworkDB) handleNetworkEvent(nEvent *NetworkEvent) bool {

 }

 func (nDB *NetworkDB) handleTableEvent(tEvent *TableEvent) bool {

-	// Update our local clock if the received messages has newer

-	// time.

+	// Update our local clock if the received messages has newer time.

 	nDB.tableClock.Witness(tEvent.LTime)

 	// Ignore the table events for networks that are in the process of going away

@@ -235,20 +234,26 @@ func (nDB *NetworkDB) handleTableEvent(tEvent *TableEvent) bool {

 		node:     tEvent.NodeName,

 		value:    tEvent.Value,

 		deleting: tEvent.Type == TableEventTypeDelete,

+		reapTime: time.Duration(tEvent.ResidualReapTime) * time.Second,

 	}

-	if e.deleting {

+	// All the entries marked for deletion should have a reapTime set greater than 0

+	// This case can happens if the cluster is running different versions of the engine where the old version does not have the

+	// field. In both cases we should raise a warning message

+	if e.deleting && e.reapTime == 0 {

+		logrus.Warnf("handleTableEvent object %+v has a 0 reapTime, is the cluster running the same docker engine version?", tEvent)

 		e.reapTime = reapInterval

 	}

 	nDB.Lock()

-	nDB.indexes[byTable].Insert(fmt.Sprintf("/%s/%s/%s", tEvent.TableName, tEvent.NetworkID, tEvent.Key), e)

-	nDB.indexes[byNetwork].Insert(fmt.Sprintf("/%s/%s/%s", tEvent.NetworkID, tEvent.TableName, tEvent.Key), e)

+	nDB.createOrUpdateEntry(tEvent.NetworkID, tEvent.TableName, tEvent.Key, e)

 	nDB.Unlock()

 	if err != nil && tEvent.Type == TableEventTypeDelete {

-		// If it is a delete event and we didn't have the entry here don't repropagate

-		return true

+		// If it is a delete event and we did not have a state for it, don't propagate to the application

+		// If the residual reapTime is lower than 1/6 of the total reapTime don't bother broadcasting it around

+		// most likely the cluster is already aware of it, if not who will sync with this node will catch the state too.

+		return e.reapTime >= reapPeriod/6

 	}

 	var op opType

@@ -303,22 +308,17 @@ func (nDB *NetworkDB) handleTableMessage(buf []byte, isBulkSync bool) {

 		n, ok := nDB.networks[nDB.config.NodeName][tEvent.NetworkID]

 		nDB.RUnlock()

-		if !ok {

-			return

-		}

-

-		broadcastQ := n.tableBroadcasts

-

-		if broadcastQ == nil {

+		// if the network is not there anymore, OR we are leaving the network OR the broadcast queue is not present

+		if !ok || n.leaving || n.tableBroadcasts == nil {

 			return

 		}

-		broadcastQ.QueueBroadcast(&tableEventMessage{

+		n.tableBroadcasts.QueueBroadcast(&tableEventMessage{

 			msg:   buf,

 			id:    tEvent.NetworkID,

 			tname: tEvent.TableName,

 			key:   tEvent.Key,

-			node:  nDB.config.NodeName,

+			node:  tEvent.NodeName,

 		})

 	}

 }

@@ -141,6 +141,11 @@ type network struct {

 	// Number of gossip messages sent related to this network during the last stats collection period

 	qMessagesSent int

+

+	// Number of entries on the network. This value is the sum of all the entries of all the tables of a specific network.

+	// Its use is for statistics purposes. It keep tracks of database size and is printed per network every StatsPrintPeriod

+	// interval

+	entriesNumber int

 }

 // Config represents the configuration of the networdb instance and

@@ -338,8 +343,7 @@ func (nDB *NetworkDB) CreateEntry(tname, nid, key string, value []byte) error {

 	}

 	nDB.Lock()

-	nDB.indexes[byTable].Insert(fmt.Sprintf("/%s/%s/%s", tname, nid, key), entry)

-	nDB.indexes[byNetwork].Insert(fmt.Sprintf("/%s/%s/%s", nid, tname, key), entry)

+	nDB.createOrUpdateEntry(nid, tname, key, entry)

 	nDB.Unlock()

 	return nil

@@ -365,8 +369,7 @@ func (nDB *NetworkDB) UpdateEntry(tname, nid, key string, value []byte) error {

 	}

 	nDB.Lock()

-	nDB.indexes[byTable].Insert(fmt.Sprintf("/%s/%s/%s", tname, nid, key), entry)

-	nDB.indexes[byNetwork].Insert(fmt.Sprintf("/%s/%s/%s", nid, tname, key), entry)

+	nDB.createOrUpdateEntry(nid, tname, key, entry)

 	nDB.Unlock()

 	return nil

@@ -410,8 +413,7 @@ func (nDB *NetworkDB) DeleteEntry(tname, nid, key string) error {

 	}

 	nDB.Lock()

-	nDB.indexes[byTable].Insert(fmt.Sprintf("/%s/%s/%s", tname, nid, key), entry)

-	nDB.indexes[byNetwork].Insert(fmt.Sprintf("/%s/%s/%s", nid, tname, key), entry)

+	nDB.createOrUpdateEntry(nid, tname, key, entry)

 	nDB.Unlock()

 	return nil

@@ -488,12 +490,10 @@ func (nDB *NetworkDB) deleteNodeNetworkEntries(nid, node string) {

 					// without doing a delete of all the objects

 					entry.ltime++

 				}

-				nDB.indexes[byTable].Insert(fmt.Sprintf("/%s/%s/%s", tname, nid, key), entry)

-				nDB.indexes[byNetwork].Insert(fmt.Sprintf("/%s/%s/%s", nid, tname, key), entry)

+				nDB.createOrUpdateEntry(nid, tname, key, entry)

 			} else {

 				// the local node is leaving the network, all the entries of remote nodes can be safely removed

-				nDB.indexes[byTable].Delete(fmt.Sprintf("/%s/%s/%s", tname, nid, key))

-				nDB.indexes[byNetwork].Delete(fmt.Sprintf("/%s/%s/%s", nid, tname, key))

+				nDB.deleteEntry(nid, tname, key)

 			}

 			nDB.broadcaster.Write(makeEvent(opDelete, tname, nid, key, entry.value))

@@ -513,8 +513,7 @@ func (nDB *NetworkDB) deleteNodeTableEntries(node string) {

 		nid := params[1]

 		key := params[2]

-		nDB.indexes[byTable].Delete(fmt.Sprintf("/%s/%s/%s", tname, nid, key))

-		nDB.indexes[byNetwork].Delete(fmt.Sprintf("/%s/%s/%s", nid, tname, key))

+		nDB.deleteEntry(nid, tname, key)

 		nDB.broadcaster.Write(makeEvent(opDelete, tname, nid, key, oldEntry.value))

 		return false

@@ -558,7 +557,12 @@ func (nDB *NetworkDB) JoinNetwork(nid string) error {

 		nodeNetworks = make(map[string]*network)

 		nDB.networks[nDB.config.NodeName] = nodeNetworks

 	}

-	nodeNetworks[nid] = &network{id: nid, ltime: ltime}

+	n, ok := nodeNetworks[nid]

+	var entries int

+	if ok {

+		entries = n.entriesNumber

+	}

+	nodeNetworks[nid] = &network{id: nid, ltime: ltime, entriesNumber: entries}

 	nodeNetworks[nid].tableBroadcasts = &memberlist.TransmitLimitedQueue{

 		NumNodes: func() int {

 			nDB.RLock()

@@ -567,6 +571,7 @@ func (nDB *NetworkDB) JoinNetwork(nid string) error {

 		},

 		RetransmitMult: 4,

 	}

+

 	nDB.addNetworkNode(nid, nDB.config.NodeName)

 	networkNodes := nDB.networkNodes[nid]

 	nDB.Unlock()

@@ -679,3 +684,29 @@ func (nDB *NetworkDB) updateLocalNetworkTime() {

 		n.ltime = ltime

 	}

 }

+

+// createOrUpdateEntry this function handles the creation or update of entries into the local

+// tree store. It is also used to keep in sync the entries number of the network (all tables are aggregated)

+func (nDB *NetworkDB) createOrUpdateEntry(nid, tname, key string, entry interface{}) (bool, bool) {

+	_, okTable := nDB.indexes[byTable].Insert(fmt.Sprintf("/%s/%s/%s", tname, nid, key), entry)

+	_, okNetwork := nDB.indexes[byNetwork].Insert(fmt.Sprintf("/%s/%s/%s", nid, tname, key), entry)

+	if !okNetwork {

+		// Add only if it is an insert not an update

+		n := nDB.networks[nDB.config.NodeName][nid]

+		n.entriesNumber++

+	}

+	return okTable, okNetwork

+}

+

+// deleteEntry this function handles the deletion of entries into the local tree store.

+// It is also used to keep in sync the entries number of the network (all tables are aggregated)

+func (nDB *NetworkDB) deleteEntry(nid, tname, key string) (bool, bool) {

+	_, okTable := nDB.indexes[byTable].Delete(fmt.Sprintf("/%s/%s/%s", tname, nid, key))

+	_, okNetwork := nDB.indexes[byNetwork].Delete(fmt.Sprintf("/%s/%s/%s", nid, tname, key))

+	if okNetwork {

+		// Remove only if the delete is successful

+		n := nDB.networks[nDB.config.NodeName][nid]

+		n.entriesNumber--

+	}

+	return okTable, okNetwork

+}

@@ -1,6 +1,5 @@

-// Code generated by protoc-gen-gogo.

+// Code generated by protoc-gen-gogo. DO NOT EDIT.

 // source: networkdb.proto

-// DO NOT EDIT!

 /*

 	Package networkdb is a generated protocol buffer package.

@@ -28,9 +27,6 @@ import _ "github.com/gogo/protobuf/gogoproto"

 import github_com_hashicorp_serf_serf "github.com/hashicorp/serf/serf"

 import strings "strings"

-import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"

-import sort "sort"

-import strconv "strconv"

 import reflect "reflect"

 import io "io"

@@ -42,7 +38,9 @@ var _ = math.Inf

 // This is a compile-time assertion to ensure that this generated file

 // is compatible with the proto package it is being compiled against.

-const _ = proto.GoGoProtoPackageIsVersion1

+// A compilation error at this line likely means your copy of the

+// proto package needs to be updated.

+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

 // MessageType enum defines all the core message types that networkdb

 // uses to communicate to peers.

@@ -192,6 +190,20 @@ func (m *GossipMessage) Reset()                    { *m = GossipMessage{} }

 func (*GossipMessage) ProtoMessage()               {}

 func (*GossipMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{0} }

+func (m *GossipMessage) GetType() MessageType {

+	if m != nil {

+		return m.Type

+	}

+	return MessageTypeInvalid

+}

+

+func (m *GossipMessage) GetData() []byte {

+	if m != nil {

+		return m.Data

+	}

+	return nil

+}

+

 // NodeEvent message payload definition.

 type NodeEvent struct {

 	Type NodeEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.NodeEvent_Type" json:"type,omitempty"`

@@ -207,6 +219,20 @@ func (m *NodeEvent) Reset()                    { *m = NodeEvent{} }

 func (*NodeEvent) ProtoMessage()               {}

 func (*NodeEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{1} }

+func (m *NodeEvent) GetType() NodeEvent_Type {

+	if m != nil {

+		return m.Type

+	}

+	return NodeEventTypeInvalid

+}

+

+func (m *NodeEvent) GetNodeName() string {

+	if m != nil {

+		return m.NodeName

+	}

+	return ""

+}

+

 // NetworkEvent message payload definition.

 type NetworkEvent struct {

 	Type NetworkEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.NetworkEvent_Type" json:"type,omitempty"`

@@ -224,6 +250,27 @@ func (m *NetworkEvent) Reset()                    { *m = NetworkEvent{} }

 func (*NetworkEvent) ProtoMessage()               {}

 func (*NetworkEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{2} }

+func (m *NetworkEvent) GetType() NetworkEvent_Type {

+	if m != nil {

+		return m.Type

+	}

+	return NetworkEventTypeInvalid

+}

+

+func (m *NetworkEvent) GetNodeName() string {

+	if m != nil {

+		return m.NodeName

+	}

+	return ""

+}

+

+func (m *NetworkEvent) GetNetworkID() string {

+	if m != nil {

+		return m.NetworkID

+	}

+	return ""

+}

+

 // NetworkEntry for push pull of networks.

 type NetworkEntry struct {

 	// ID of the network

@@ -241,6 +288,27 @@ func (m *NetworkEntry) Reset()                    { *m = NetworkEntry{} }

 func (*NetworkEntry) ProtoMessage()               {}

 func (*NetworkEntry) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{3} }

+func (m *NetworkEntry) GetNetworkID() string {

+	if m != nil {

+		return m.NetworkID

+	}

+	return ""

+}

+

+func (m *NetworkEntry) GetNodeName() string {

+	if m != nil {

+		return m.NodeName

+	}

+	return ""

+}

+

+func (m *NetworkEntry) GetLeaving() bool {

+	if m != nil {

+		return m.Leaving

+	}

+	return false

+}

+

 // NetworkPushpull message payload definition.

 type NetworkPushPull struct {

 	// Lamport time when this push pull was initiated.

@@ -261,6 +329,13 @@ func (m *NetworkPushPull) GetNetworks() []*NetworkEntry {

 	return nil

 }

+func (m *NetworkPushPull) GetNodeName() string {

+	if m != nil {

+		return m.NodeName

+	}

+	return ""

+}

+

 // TableEvent message payload definition.

 type TableEvent struct {

 	Type TableEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.TableEvent_Type" json:"type,omitempty"`

@@ -276,12 +351,63 @@ type TableEvent struct {

 	Key string `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`

 	// Entry value.

 	Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`

+	// Residual reap time for the entry before getting deleted in seconds

+	ResidualReapTime int32 `protobuf:"varint,8,opt,name=residual_reap_time,json=residualReapTime,proto3" json:"residual_reap_time,omitempty"`

 }

 func (m *TableEvent) Reset()                    { *m = TableEvent{} }

 func (*TableEvent) ProtoMessage()               {}

 func (*TableEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{5} }

+func (m *TableEvent) GetType() TableEvent_Type {

+	if m != nil {

+		return m.Type

+	}

+	return TableEventTypeInvalid

+}

+

+func (m *TableEvent) GetNodeName() string {

+	if m != nil {

+		return m.NodeName

+	}

+	return ""

+}

+

+func (m *TableEvent) GetNetworkID() string {

+	if m != nil {

+		return m.NetworkID

+	}

+	return ""

+}

+

+func (m *TableEvent) GetTableName() string {

+	if m != nil {

+		return m.TableName

+	}

+	return ""

+}

+

+func (m *TableEvent) GetKey() string {

+	if m != nil {

+		return m.Key

+	}

+	return ""

+}

+

+func (m *TableEvent) GetValue() []byte {

+	if m != nil {

+		return m.Value

+	}

+	return nil

+}

+

+func (m *TableEvent) GetResidualReapTime() int32 {

+	if m != nil {

+		return m.ResidualReapTime

+	}

+	return 0

+}

+

 // BulkSync message payload definition.

 type BulkSyncMessage struct {

 	// Lamport time when this bulk sync was initiated.

@@ -302,6 +428,34 @@ func (m *BulkSyncMessage) Reset()                    { *m = BulkSyncMessage{} }

 func (*BulkSyncMessage) ProtoMessage()               {}

 func (*BulkSyncMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{6} }

+func (m *BulkSyncMessage) GetUnsolicited() bool {

+	if m != nil {

+		return m.Unsolicited

+	}

+	return false

+}

+

+func (m *BulkSyncMessage) GetNodeName() string {

+	if m != nil {

+		return m.NodeName

+	}

+	return ""

+}

+

+func (m *BulkSyncMessage) GetNetworks() []string {

+	if m != nil {

+		return m.Networks

+	}

+	return nil

+}

+

+func (m *BulkSyncMessage) GetPayload() []byte {

+	if m != nil {

+		return m.Payload

+	}

+	return nil

+}

+

 // Compound message payload definition.

 type CompoundMessage struct {

 	// A list of simple messages.

@@ -322,7 +476,7 @@ func (m *CompoundMessage) GetMessages() []*CompoundMessage_SimpleMessage {

 type CompoundMessage_SimpleMessage struct {

 	// Bytestring payload of a message constructed using

 	// other message type definitions.

-	Payload []byte `protobuf:"bytes,1,opt,name=Payload,json=payload,proto3" json:"Payload,omitempty"`

+	Payload []byte `protobuf:"bytes,1,opt,name=Payload,proto3" json:"Payload,omitempty"`

 }

 func (m *CompoundMessage_SimpleMessage) Reset()      { *m = CompoundMessage_SimpleMessage{} }

@@ -331,6 +485,13 @@ func (*CompoundMessage_SimpleMessage) Descriptor() ([]byte, []int) {

 	return fileDescriptorNetworkdb, []int{7, 0}

 }

+func (m *CompoundMessage_SimpleMessage) GetPayload() []byte {

+	if m != nil {

+		return m.Payload

+	}

+	return nil

+}

+

 func init() {

 	proto.RegisterType((*GossipMessage)(nil), "networkdb.GossipMessage")

 	proto.RegisterType((*NodeEvent)(nil), "networkdb.NodeEvent")

@@ -413,7 +574,7 @@ func (this *TableEvent) GoString() string {

 	if this == nil {

 		return "nil"

 	}

-	s := make([]string, 0, 11)

+	s := make([]string, 0, 12)

 	s = append(s, "&networkdb.TableEvent{")

 	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")

 	s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")

@@ -422,6 +583,7 @@ func (this *TableEvent) GoString() string {

 	s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n")

 	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")

 	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")

+	s = append(s, "ResidualReapTime: "+fmt.Sprintf("%#v", this.ResidualReapTime)+",\n")

 	s = append(s, "}")

 	return strings.Join(s, "")

 }

@@ -469,197 +631,180 @@ func valueToGoStringNetworkdb(v interface{}, typ string) string {

 	pv := reflect.Indirect(rv).Interface()

 	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)

 }

-func extensionToGoStringNetworkdb(e map[int32]github_com_gogo_protobuf_proto.Extension) string {

-	if e == nil {

-		return "nil"

-	}

-	s := "map[int32]proto.Extension{"

-	keys := make([]int, 0, len(e))

-	for k := range e {

-		keys = append(keys, int(k))

-	}

-	sort.Ints(keys)

-	ss := []string{}

-	for _, k := range keys {

-		ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())

-	}

-	s += strings.Join(ss, ",") + "}"

-	return s

-}

-func (m *GossipMessage) Marshal() (data []byte, err error) {

+func (m *GossipMessage) Marshal() (dAtA []byte, err error) {

 	size := m.Size()

-	data = make([]byte, size)

-	n, err := m.MarshalTo(data)

+	dAtA = make([]byte, size)

+	n, err := m.MarshalTo(dAtA)

 	if err != nil {

 		return nil, err

 	}

-	return data[:n], nil

+	return dAtA[:n], nil

 }

-func (m *GossipMessage) MarshalTo(data []byte) (int, error) {

+func (m *GossipMessage) MarshalTo(dAtA []byte) (int, error) {

 	var i int

 	_ = i

 	var l int

 	_ = l

 	if m.Type != 0 {

-		data[i] = 0x8

+		dAtA[i] = 0x8

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.Type))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.Type))

 	}

 	if len(m.Data) > 0 {

-		data[i] = 0x12

+		dAtA[i] = 0x12

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.Data)))

-		i += copy(data[i:], m.Data)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.Data)))

+		i += copy(dAtA[i:], m.Data)

 	}

 	return i, nil

 }

-func (m *NodeEvent) Marshal() (data []byte, err error) {

+func (m *NodeEvent) Marshal() (dAtA []byte, err error) {

 	size := m.Size()

-	data = make([]byte, size)

-	n, err := m.MarshalTo(data)

+	dAtA = make([]byte, size)

+	n, err := m.MarshalTo(dAtA)

 	if err != nil {

 		return nil, err

 	}

-	return data[:n], nil

+	return dAtA[:n], nil

 }

-func (m *NodeEvent) MarshalTo(data []byte) (int, error) {

+func (m *NodeEvent) MarshalTo(dAtA []byte) (int, error) {

 	var i int

 	_ = i

 	var l int

 	_ = l

 	if m.Type != 0 {

-		data[i] = 0x8

+		dAtA[i] = 0x8

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.Type))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.Type))

 	}

 	if m.LTime != 0 {

-		data[i] = 0x10

+		dAtA[i] = 0x10

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.LTime))

 	}

 	if len(m.NodeName) > 0 {

-		data[i] = 0x1a

+		dAtA[i] = 0x1a

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))

-		i += copy(data[i:], m.NodeName)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NodeName)))

+		i += copy(dAtA[i:], m.NodeName)

 	}

 	return i, nil

 }

-func (m *NetworkEvent) Marshal() (data []byte, err error) {

+func (m *NetworkEvent) Marshal() (dAtA []byte, err error) {

 	size := m.Size()

-	data = make([]byte, size)

-	n, err := m.MarshalTo(data)

+	dAtA = make([]byte, size)

+	n, err := m.MarshalTo(dAtA)

 	if err != nil {

 		return nil, err

 	}

-	return data[:n], nil

+	return dAtA[:n], nil

 }

-func (m *NetworkEvent) MarshalTo(data []byte) (int, error) {

+func (m *NetworkEvent) MarshalTo(dAtA []byte) (int, error) {

 	var i int

 	_ = i

 	var l int

 	_ = l

 	if m.Type != 0 {

-		data[i] = 0x8

+		dAtA[i] = 0x8

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.Type))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.Type))

 	}

 	if m.LTime != 0 {

-		data[i] = 0x10

+		dAtA[i] = 0x10

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.LTime))

 	}

 	if len(m.NodeName) > 0 {

-		data[i] = 0x1a

+		dAtA[i] = 0x1a

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))

-		i += copy(data[i:], m.NodeName)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NodeName)))

+		i += copy(dAtA[i:], m.NodeName)

 	}

 	if len(m.NetworkID) > 0 {

-		data[i] = 0x22

+		dAtA[i] = 0x22

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))

-		i += copy(data[i:], m.NetworkID)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NetworkID)))

+		i += copy(dAtA[i:], m.NetworkID)

 	}

 	return i, nil

 }

-func (m *NetworkEntry) Marshal() (data []byte, err error) {

+func (m *NetworkEntry) Marshal() (dAtA []byte, err error) {

 	size := m.Size()

-	data = make([]byte, size)

-	n, err := m.MarshalTo(data)

+	dAtA = make([]byte, size)

+	n, err := m.MarshalTo(dAtA)

 	if err != nil {

 		return nil, err

 	}

-	return data[:n], nil

+	return dAtA[:n], nil

 }

-func (m *NetworkEntry) MarshalTo(data []byte) (int, error) {

+func (m *NetworkEntry) MarshalTo(dAtA []byte) (int, error) {

 	var i int

 	_ = i

 	var l int

 	_ = l

 	if len(m.NetworkID) > 0 {

-		data[i] = 0xa

+		dAtA[i] = 0xa

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))

-		i += copy(data[i:], m.NetworkID)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NetworkID)))

+		i += copy(dAtA[i:], m.NetworkID)

 	}

 	if m.LTime != 0 {

-		data[i] = 0x10

+		dAtA[i] = 0x10

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.LTime))

 	}

 	if len(m.NodeName) > 0 {

-		data[i] = 0x1a

+		dAtA[i] = 0x1a

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))

-		i += copy(data[i:], m.NodeName)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NodeName)))

+		i += copy(dAtA[i:], m.NodeName)

 	}

 	if m.Leaving {

-		data[i] = 0x20

+		dAtA[i] = 0x20

 		i++

 		if m.Leaving {

-			data[i] = 1

+			dAtA[i] = 1

 		} else {

-			data[i] = 0

+			dAtA[i] = 0

 		}

 		i++

 	}

 	return i, nil

 }

-func (m *NetworkPushPull) Marshal() (data []byte, err error) {

+func (m *NetworkPushPull) Marshal() (dAtA []byte, err error) {

 	size := m.Size()

-	data = make([]byte, size)

-	n, err := m.MarshalTo(data)

+	dAtA = make([]byte, size)

+	n, err := m.MarshalTo(dAtA)

 	if err != nil {

 		return nil, err

 	}

-	return data[:n], nil

+	return dAtA[:n], nil

 }

-func (m *NetworkPushPull) MarshalTo(data []byte) (int, error) {

+func (m *NetworkPushPull) MarshalTo(dAtA []byte) (int, error) {

 	var i int

 	_ = i

 	var l int

 	_ = l

 	if m.LTime != 0 {

-		data[i] = 0x8

+		dAtA[i] = 0x8

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.LTime))

 	}

 	if len(m.Networks) > 0 {

 		for _, msg := range m.Networks {

-			data[i] = 0x12

+			dAtA[i] = 0x12

 			i++

-			i = encodeVarintNetworkdb(data, i, uint64(msg.Size()))

-			n, err := msg.MarshalTo(data[i:])

+			i = encodeVarintNetworkdb(dAtA, i, uint64(msg.Size()))

+			n, err := msg.MarshalTo(dAtA[i:])

 			if err != nil {

 				return 0, err

 			}

@@ -667,153 +812,158 @@ func (m *NetworkPushPull) MarshalTo(data []byte) (int, error) {

 		}

 	}

 	if len(m.NodeName) > 0 {

-		data[i] = 0x1a

+		dAtA[i] = 0x1a

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))

-		i += copy(data[i:], m.NodeName)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NodeName)))

+		i += copy(dAtA[i:], m.NodeName)

 	}

 	return i, nil

 }

-func (m *TableEvent) Marshal() (data []byte, err error) {

+func (m *TableEvent) Marshal() (dAtA []byte, err error) {

 	size := m.Size()

-	data = make([]byte, size)

-	n, err := m.MarshalTo(data)

+	dAtA = make([]byte, size)

+	n, err := m.MarshalTo(dAtA)

 	if err != nil {

 		return nil, err

 	}

-	return data[:n], nil

+	return dAtA[:n], nil

 }

-func (m *TableEvent) MarshalTo(data []byte) (int, error) {

+func (m *TableEvent) MarshalTo(dAtA []byte) (int, error) {

 	var i int

 	_ = i

 	var l int

 	_ = l

 	if m.Type != 0 {

-		data[i] = 0x8

+		dAtA[i] = 0x8

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.Type))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.Type))

 	}

 	if m.LTime != 0 {

-		data[i] = 0x10

+		dAtA[i] = 0x10

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(m.LTime))

+		i = encodeVarintNetworkdb(dAtA, i, uint64(m.LTime))

 	}

 	if len(m.NodeName) > 0 {

-		data[i] = 0x1a

+		dAtA[i] = 0x1a

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))

-		i += copy(data[i:], m.NodeName)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NodeName)))

+		i += copy(dAtA[i:], m.NodeName)

 	}

 	if len(m.NetworkID) > 0 {

-		data[i] = 0x22

+		dAtA[i] = 0x22

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))

-		i += copy(data[i:], m.NetworkID)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.NetworkID)))

+		i += copy(dAtA[i:], m.NetworkID)

 	}

 	if len(m.TableName) > 0 {

-		data[i] = 0x2a

+		dAtA[i] = 0x2a

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.TableName)))

-		i += copy(data[i:], m.TableName)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.TableName)))

+		i += copy(dAtA[i:], m.TableName)

 	}

 	if len(m.Key) > 0 {

-		data[i] = 0x32

+		dAtA[i] = 0x32

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.Key)))

-		i += copy(data[i:], m.Key)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.Key)))

+		i += copy(dAtA[i:], m.Key)

 	}

 	if len(m.Value) > 0 {

-		data[i] = 0x3a

+		dAtA[i] = 0x3a

 		i++

-		i = encodeVarintNetworkdb(data, i, uint64(len(m.Value)))

-		i += copy(data[i:], m.Value)

+		i = encodeVarintNetworkdb(dAtA, i, uint64(len(m.Value)))

+		i += copy(dAtA[i:], m.Value)

+	}

+	if m.ResidualReapTime != 0 {

+		dAtA[i] = 0x40