5f5dad3c02
Currently if there is any transient gossip failure in any node the recoevry process depends on other nodes propogating the information indirectly. In cases if these transient failures affects all the nodes that this node has in its memberlist then this node will be permenantly cutoff from the the gossip channel. Added node state management code in networkdb to address these problems by trying to rejoin the cluster via the failed nodes when there is a failure. This also necessitates the need to add new messages called node event messages to differentiate between node leave and node failure. Signed-off-by: Jana Radhakrishnan <mrjana@docker.com>
2554 lines
66 KiB
Go
2554 lines
66 KiB
Go
// Code generated by protoc-gen-gogo.
|
|
// source: networkdb.proto
|
|
// DO NOT EDIT!
|
|
|
|
/*
|
|
Package networkdb is a generated protocol buffer package.
|
|
|
|
It is generated from these files:
|
|
networkdb.proto
|
|
|
|
It has these top-level messages:
|
|
GossipMessage
|
|
NodeEvent
|
|
NetworkEvent
|
|
NetworkEntry
|
|
NetworkPushPull
|
|
TableEvent
|
|
BulkSyncMessage
|
|
CompoundMessage
|
|
*/
|
|
package networkdb
|
|
|
|
import proto "github.com/gogo/protobuf/proto"
|
|
import fmt "fmt"
|
|
import math "math"
|
|
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"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
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
|
|
|
|
// MessageType enum defines all the core message types that networkdb
|
|
// uses to communicate to peers.
|
|
type MessageType int32
|
|
|
|
const (
|
|
MessageTypeInvalid MessageType = 0
|
|
// NetworEvent message type is used to communicate network
|
|
// attachments on the node.
|
|
MessageTypeNetworkEvent MessageType = 1
|
|
// TableEvent message type is used to communicate any table
|
|
// CRUD event that happened on the node.
|
|
MessageTypeTableEvent MessageType = 2
|
|
// PushPull message type is used to syncup all network
|
|
// attachments on a peer node either during startup of this
|
|
// node or with a random peer node periodically thereafter.
|
|
MessageTypePushPull MessageType = 3
|
|
// BulkSync message is used to bulksync the whole networkdb
|
|
// state with a peer node during startup of this node or with
|
|
// a random peer node periodically thereafter.
|
|
MessageTypeBulkSync MessageType = 4
|
|
// Compound message type is used to form a compound message
|
|
// which is a pack of many message of above types, packed into
|
|
// a single compound message.
|
|
MessageTypeCompound MessageType = 5
|
|
// NodeEvent message type is used to communicare node
|
|
// join/leave events in the cluster
|
|
MessageTypeNodeEvent MessageType = 6
|
|
)
|
|
|
|
var MessageType_name = map[int32]string{
|
|
0: "INVALID",
|
|
1: "NETWORK_EVENT",
|
|
2: "TABLE_EVENT",
|
|
3: "PUSH_PULL",
|
|
4: "BULK_SYNC",
|
|
5: "COMPOUND",
|
|
6: "NODE_EVENT",
|
|
}
|
|
var MessageType_value = map[string]int32{
|
|
"INVALID": 0,
|
|
"NETWORK_EVENT": 1,
|
|
"TABLE_EVENT": 2,
|
|
"PUSH_PULL": 3,
|
|
"BULK_SYNC": 4,
|
|
"COMPOUND": 5,
|
|
"NODE_EVENT": 6,
|
|
}
|
|
|
|
func (x MessageType) String() string {
|
|
return proto.EnumName(MessageType_name, int32(x))
|
|
}
|
|
func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{0} }
|
|
|
|
type NodeEvent_Type int32
|
|
|
|
const (
|
|
NodeEventTypeInvalid NodeEvent_Type = 0
|
|
// Join event is generated when this node joins the cluster.
|
|
NodeEventTypeJoin NodeEvent_Type = 1
|
|
// Leave event is generated when this node leaves the cluster.
|
|
NodeEventTypeLeave NodeEvent_Type = 2
|
|
)
|
|
|
|
var NodeEvent_Type_name = map[int32]string{
|
|
0: "INVALID",
|
|
1: "JOIN",
|
|
2: "LEAVE",
|
|
}
|
|
var NodeEvent_Type_value = map[string]int32{
|
|
"INVALID": 0,
|
|
"JOIN": 1,
|
|
"LEAVE": 2,
|
|
}
|
|
|
|
func (x NodeEvent_Type) String() string {
|
|
return proto.EnumName(NodeEvent_Type_name, int32(x))
|
|
}
|
|
func (NodeEvent_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{1, 0} }
|
|
|
|
type NetworkEvent_Type int32
|
|
|
|
const (
|
|
NetworkEventTypeInvalid NetworkEvent_Type = 0
|
|
// Join event is generated when this node joins a network.
|
|
NetworkEventTypeJoin NetworkEvent_Type = 1
|
|
// Leave event is generated when this node leaves a network.
|
|
NetworkEventTypeLeave NetworkEvent_Type = 2
|
|
)
|
|
|
|
var NetworkEvent_Type_name = map[int32]string{
|
|
0: "INVALID",
|
|
1: "JOIN",
|
|
2: "LEAVE",
|
|
}
|
|
var NetworkEvent_Type_value = map[string]int32{
|
|
"INVALID": 0,
|
|
"JOIN": 1,
|
|
"LEAVE": 2,
|
|
}
|
|
|
|
func (x NetworkEvent_Type) String() string {
|
|
return proto.EnumName(NetworkEvent_Type_name, int32(x))
|
|
}
|
|
func (NetworkEvent_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{2, 0} }
|
|
|
|
type TableEvent_Type int32
|
|
|
|
const (
|
|
TableEventTypeInvalid TableEvent_Type = 0
|
|
// Create signifies that this table entry was just
|
|
// created.
|
|
TableEventTypeCreate TableEvent_Type = 1
|
|
// Update signifies that this table entry was just
|
|
// updated.
|
|
TableEventTypeUpdate TableEvent_Type = 2
|
|
// Delete signifies that this table entry was just
|
|
// updated.
|
|
TableEventTypeDelete TableEvent_Type = 3
|
|
)
|
|
|
|
var TableEvent_Type_name = map[int32]string{
|
|
0: "INVALID",
|
|
1: "CREATE",
|
|
2: "UPDATE",
|
|
3: "DELETE",
|
|
}
|
|
var TableEvent_Type_value = map[string]int32{
|
|
"INVALID": 0,
|
|
"CREATE": 1,
|
|
"UPDATE": 2,
|
|
"DELETE": 3,
|
|
}
|
|
|
|
func (x TableEvent_Type) String() string {
|
|
return proto.EnumName(TableEvent_Type_name, int32(x))
|
|
}
|
|
func (TableEvent_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{5, 0} }
|
|
|
|
// GossipMessage is a basic message header used by all messages types.
|
|
type GossipMessage struct {
|
|
Type MessageType `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.MessageType" json:"type,omitempty"`
|
|
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
|
|
}
|
|
|
|
func (m *GossipMessage) Reset() { *m = GossipMessage{} }
|
|
func (*GossipMessage) ProtoMessage() {}
|
|
func (*GossipMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{0} }
|
|
|
|
// NodeEvent message payload definition.
|
|
type NodeEvent struct {
|
|
Type NodeEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.NodeEvent_Type" json:"type,omitempty"`
|
|
// Lamport time using a network lamport clock indicating the
|
|
// time this event was generated on the node where it was
|
|
// generated.
|
|
LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
|
|
// Source node name.
|
|
NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
|
|
}
|
|
|
|
func (m *NodeEvent) Reset() { *m = NodeEvent{} }
|
|
func (*NodeEvent) ProtoMessage() {}
|
|
func (*NodeEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{1} }
|
|
|
|
// NetworkEvent message payload definition.
|
|
type NetworkEvent struct {
|
|
Type NetworkEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.NetworkEvent_Type" json:"type,omitempty"`
|
|
// Lamport time using a network lamport clock indicating the
|
|
// time this event was generated on the node where it was
|
|
// generated.
|
|
LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
|
|
// Source node name.
|
|
NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
|
|
// ID of the network for which the event is generated.
|
|
NetworkID string `protobuf:"bytes,4,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
|
|
}
|
|
|
|
func (m *NetworkEvent) Reset() { *m = NetworkEvent{} }
|
|
func (*NetworkEvent) ProtoMessage() {}
|
|
func (*NetworkEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{2} }
|
|
|
|
// NetworkEntry for push pull of networks.
|
|
type NetworkEntry struct {
|
|
// ID of the network
|
|
NetworkID string `protobuf:"bytes,1,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
|
|
// Latest lamport time of the network attachment when this
|
|
// network event was recorded.
|
|
LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
|
|
// Source node name where this network attachment happened.
|
|
NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
|
|
// Indicates if a leave from this network is in progress.
|
|
Leaving bool `protobuf:"varint,4,opt,name=leaving,proto3" json:"leaving,omitempty"`
|
|
}
|
|
|
|
func (m *NetworkEntry) Reset() { *m = NetworkEntry{} }
|
|
func (*NetworkEntry) ProtoMessage() {}
|
|
func (*NetworkEntry) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{3} }
|
|
|
|
// NetworkPushpull message payload definition.
|
|
type NetworkPushPull struct {
|
|
// Lamport time when this push pull was initiated.
|
|
LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,1,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
|
|
Networks []*NetworkEntry `protobuf:"bytes,2,rep,name=networks" json:"networks,omitempty"`
|
|
// Name of the node sending this push pull payload.
|
|
NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
|
|
}
|
|
|
|
func (m *NetworkPushPull) Reset() { *m = NetworkPushPull{} }
|
|
func (*NetworkPushPull) ProtoMessage() {}
|
|
func (*NetworkPushPull) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{4} }
|
|
|
|
func (m *NetworkPushPull) GetNetworks() []*NetworkEntry {
|
|
if m != nil {
|
|
return m.Networks
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TableEvent message payload definition.
|
|
type TableEvent struct {
|
|
Type TableEvent_Type `protobuf:"varint,1,opt,name=type,proto3,enum=networkdb.TableEvent_Type" json:"type,omitempty"`
|
|
// Lamport time when this event was generated.
|
|
LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,2,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
|
|
// Node name where this event originated.
|
|
NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
|
|
// ID of the network to which this table entry belongs.
|
|
NetworkID string `protobuf:"bytes,4,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
|
|
// Name of the table to which this table entry belongs.
|
|
TableName string `protobuf:"bytes,5,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
|
|
// Entry key.
|
|
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"`
|
|
}
|
|
|
|
func (m *TableEvent) Reset() { *m = TableEvent{} }
|
|
func (*TableEvent) ProtoMessage() {}
|
|
func (*TableEvent) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{5} }
|
|
|
|
// BulkSync message payload definition.
|
|
type BulkSyncMessage struct {
|
|
// Lamport time when this bulk sync was initiated.
|
|
LTime github_com_hashicorp_serf_serf.LamportTime `protobuf:"varint,1,opt,name=l_time,json=lTime,proto3,customtype=github.com/hashicorp/serf/serf.LamportTime" json:"l_time"`
|
|
// Indicates if this bulksync is a response to a bulk sync
|
|
// request from a peer node.
|
|
Unsolicited bool `protobuf:"varint,2,opt,name=unsolicited,proto3" json:"unsolicited,omitempty"`
|
|
// Name of the node which is producing this bulk sync message.
|
|
NodeName string `protobuf:"bytes,3,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
|
|
// List of network names whose table entries are getting
|
|
// bulksynced as part of the bulksync.
|
|
Networks []string `protobuf:"bytes,4,rep,name=networks" json:"networks,omitempty"`
|
|
// Bulksync payload
|
|
Payload []byte `protobuf:"bytes,5,opt,name=payload,proto3" json:"payload,omitempty"`
|
|
}
|
|
|
|
func (m *BulkSyncMessage) Reset() { *m = BulkSyncMessage{} }
|
|
func (*BulkSyncMessage) ProtoMessage() {}
|
|
func (*BulkSyncMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{6} }
|
|
|
|
// Compound message payload definition.
|
|
type CompoundMessage struct {
|
|
// A list of simple messages.
|
|
Messages []*CompoundMessage_SimpleMessage `protobuf:"bytes,1,rep,name=messages" json:"messages,omitempty"`
|
|
}
|
|
|
|
func (m *CompoundMessage) Reset() { *m = CompoundMessage{} }
|
|
func (*CompoundMessage) ProtoMessage() {}
|
|
func (*CompoundMessage) Descriptor() ([]byte, []int) { return fileDescriptorNetworkdb, []int{7} }
|
|
|
|
func (m *CompoundMessage) GetMessages() []*CompoundMessage_SimpleMessage {
|
|
if m != nil {
|
|
return m.Messages
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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"`
|
|
}
|
|
|
|
func (m *CompoundMessage_SimpleMessage) Reset() { *m = CompoundMessage_SimpleMessage{} }
|
|
func (*CompoundMessage_SimpleMessage) ProtoMessage() {}
|
|
func (*CompoundMessage_SimpleMessage) Descriptor() ([]byte, []int) {
|
|
return fileDescriptorNetworkdb, []int{7, 0}
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*GossipMessage)(nil), "networkdb.GossipMessage")
|
|
proto.RegisterType((*NodeEvent)(nil), "networkdb.NodeEvent")
|
|
proto.RegisterType((*NetworkEvent)(nil), "networkdb.NetworkEvent")
|
|
proto.RegisterType((*NetworkEntry)(nil), "networkdb.NetworkEntry")
|
|
proto.RegisterType((*NetworkPushPull)(nil), "networkdb.NetworkPushPull")
|
|
proto.RegisterType((*TableEvent)(nil), "networkdb.TableEvent")
|
|
proto.RegisterType((*BulkSyncMessage)(nil), "networkdb.BulkSyncMessage")
|
|
proto.RegisterType((*CompoundMessage)(nil), "networkdb.CompoundMessage")
|
|
proto.RegisterType((*CompoundMessage_SimpleMessage)(nil), "networkdb.CompoundMessage.SimpleMessage")
|
|
proto.RegisterEnum("networkdb.MessageType", MessageType_name, MessageType_value)
|
|
proto.RegisterEnum("networkdb.NodeEvent_Type", NodeEvent_Type_name, NodeEvent_Type_value)
|
|
proto.RegisterEnum("networkdb.NetworkEvent_Type", NetworkEvent_Type_name, NetworkEvent_Type_value)
|
|
proto.RegisterEnum("networkdb.TableEvent_Type", TableEvent_Type_name, TableEvent_Type_value)
|
|
}
|
|
func (this *GossipMessage) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 6)
|
|
s = append(s, "&networkdb.GossipMessage{")
|
|
s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
|
|
s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *NodeEvent) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&networkdb.NodeEvent{")
|
|
s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
|
|
s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
|
|
s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *NetworkEvent) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 8)
|
|
s = append(s, "&networkdb.NetworkEvent{")
|
|
s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
|
|
s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
|
|
s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
|
|
s = append(s, "NetworkID: "+fmt.Sprintf("%#v", this.NetworkID)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *NetworkEntry) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 8)
|
|
s = append(s, "&networkdb.NetworkEntry{")
|
|
s = append(s, "NetworkID: "+fmt.Sprintf("%#v", this.NetworkID)+",\n")
|
|
s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
|
|
s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
|
|
s = append(s, "Leaving: "+fmt.Sprintf("%#v", this.Leaving)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *NetworkPushPull) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 7)
|
|
s = append(s, "&networkdb.NetworkPushPull{")
|
|
s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
|
|
if this.Networks != nil {
|
|
s = append(s, "Networks: "+fmt.Sprintf("%#v", this.Networks)+",\n")
|
|
}
|
|
s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *TableEvent) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 11)
|
|
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")
|
|
s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
|
|
s = append(s, "NetworkID: "+fmt.Sprintf("%#v", this.NetworkID)+",\n")
|
|
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, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *BulkSyncMessage) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 9)
|
|
s = append(s, "&networkdb.BulkSyncMessage{")
|
|
s = append(s, "LTime: "+fmt.Sprintf("%#v", this.LTime)+",\n")
|
|
s = append(s, "Unsolicited: "+fmt.Sprintf("%#v", this.Unsolicited)+",\n")
|
|
s = append(s, "NodeName: "+fmt.Sprintf("%#v", this.NodeName)+",\n")
|
|
s = append(s, "Networks: "+fmt.Sprintf("%#v", this.Networks)+",\n")
|
|
s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *CompoundMessage) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&networkdb.CompoundMessage{")
|
|
if this.Messages != nil {
|
|
s = append(s, "Messages: "+fmt.Sprintf("%#v", this.Messages)+",\n")
|
|
}
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func (this *CompoundMessage_SimpleMessage) GoString() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := make([]string, 0, 5)
|
|
s = append(s, "&networkdb.CompoundMessage_SimpleMessage{")
|
|
s = append(s, "Payload: "+fmt.Sprintf("%#v", this.Payload)+",\n")
|
|
s = append(s, "}")
|
|
return strings.Join(s, "")
|
|
}
|
|
func valueToGoStringNetworkdb(v interface{}, typ string) string {
|
|
rv := reflect.ValueOf(v)
|
|
if rv.IsNil() {
|
|
return "nil"
|
|
}
|
|
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) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *GossipMessage) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.Type))
|
|
}
|
|
if len(m.Data) > 0 {
|
|
data[i] = 0x12
|
|
i++
|
|
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) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *NodeEvent) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.Type))
|
|
}
|
|
if m.LTime != 0 {
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
|
|
}
|
|
if len(m.NodeName) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
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) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *NetworkEvent) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.Type))
|
|
}
|
|
if m.LTime != 0 {
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
|
|
}
|
|
if len(m.NodeName) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
|
|
i += copy(data[i:], m.NodeName)
|
|
}
|
|
if len(m.NetworkID) > 0 {
|
|
data[i] = 0x22
|
|
i++
|
|
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) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *NetworkEntry) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.NetworkID) > 0 {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))
|
|
i += copy(data[i:], m.NetworkID)
|
|
}
|
|
if m.LTime != 0 {
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
|
|
}
|
|
if len(m.NodeName) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
|
|
i += copy(data[i:], m.NodeName)
|
|
}
|
|
if m.Leaving {
|
|
data[i] = 0x20
|
|
i++
|
|
if m.Leaving {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *NetworkPushPull) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *NetworkPushPull) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.LTime != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
|
|
}
|
|
if len(m.Networks) > 0 {
|
|
for _, msg := range m.Networks {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if len(m.NodeName) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
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) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *TableEvent) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.Type))
|
|
}
|
|
if m.LTime != 0 {
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
|
|
}
|
|
if len(m.NodeName) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
|
|
i += copy(data[i:], m.NodeName)
|
|
}
|
|
if len(m.NetworkID) > 0 {
|
|
data[i] = 0x22
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.NetworkID)))
|
|
i += copy(data[i:], m.NetworkID)
|
|
}
|
|
if len(m.TableName) > 0 {
|
|
data[i] = 0x2a
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.TableName)))
|
|
i += copy(data[i:], m.TableName)
|
|
}
|
|
if len(m.Key) > 0 {
|
|
data[i] = 0x32
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.Key)))
|
|
i += copy(data[i:], m.Key)
|
|
}
|
|
if len(m.Value) > 0 {
|
|
data[i] = 0x3a
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.Value)))
|
|
i += copy(data[i:], m.Value)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *BulkSyncMessage) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *BulkSyncMessage) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.LTime != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(m.LTime))
|
|
}
|
|
if m.Unsolicited {
|
|
data[i] = 0x10
|
|
i++
|
|
if m.Unsolicited {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if len(m.NodeName) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.NodeName)))
|
|
i += copy(data[i:], m.NodeName)
|
|
}
|
|
if len(m.Networks) > 0 {
|
|
for _, s := range m.Networks {
|
|
data[i] = 0x22
|
|
i++
|
|
l = len(s)
|
|
for l >= 1<<7 {
|
|
data[i] = uint8(uint64(l)&0x7f | 0x80)
|
|
l >>= 7
|
|
i++
|
|
}
|
|
data[i] = uint8(l)
|
|
i++
|
|
i += copy(data[i:], s)
|
|
}
|
|
}
|
|
if len(m.Payload) > 0 {
|
|
data[i] = 0x2a
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.Payload)))
|
|
i += copy(data[i:], m.Payload)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *CompoundMessage) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *CompoundMessage) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Messages) > 0 {
|
|
for _, msg := range m.Messages {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *CompoundMessage_SimpleMessage) Marshal() (data []byte, err error) {
|
|
size := m.Size()
|
|
data = make([]byte, size)
|
|
n, err := m.MarshalTo(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return data[:n], nil
|
|
}
|
|
|
|
func (m *CompoundMessage_SimpleMessage) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Payload) > 0 {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintNetworkdb(data, i, uint64(len(m.Payload)))
|
|
i += copy(data[i:], m.Payload)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func encodeFixed64Networkdb(data []byte, offset int, v uint64) int {
|
|
data[offset] = uint8(v)
|
|
data[offset+1] = uint8(v >> 8)
|
|
data[offset+2] = uint8(v >> 16)
|
|
data[offset+3] = uint8(v >> 24)
|
|
data[offset+4] = uint8(v >> 32)
|
|
data[offset+5] = uint8(v >> 40)
|
|
data[offset+6] = uint8(v >> 48)
|
|
data[offset+7] = uint8(v >> 56)
|
|
return offset + 8
|
|
}
|
|
func encodeFixed32Networkdb(data []byte, offset int, v uint32) int {
|
|
data[offset] = uint8(v)
|
|
data[offset+1] = uint8(v >> 8)
|
|
data[offset+2] = uint8(v >> 16)
|
|
data[offset+3] = uint8(v >> 24)
|
|
return offset + 4
|
|
}
|
|
func encodeVarintNetworkdb(data []byte, offset int, v uint64) int {
|
|
for v >= 1<<7 {
|
|
data[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
data[offset] = uint8(v)
|
|
return offset + 1
|
|
}
|
|
func (m *GossipMessage) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.Type))
|
|
}
|
|
l = len(m.Data)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NodeEvent) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.Type))
|
|
}
|
|
if m.LTime != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.LTime))
|
|
}
|
|
l = len(m.NodeName)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NetworkEvent) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.Type))
|
|
}
|
|
if m.LTime != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.LTime))
|
|
}
|
|
l = len(m.NodeName)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
l = len(m.NetworkID)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NetworkEntry) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
l = len(m.NetworkID)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
if m.LTime != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.LTime))
|
|
}
|
|
l = len(m.NodeName)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
if m.Leaving {
|
|
n += 2
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *NetworkPushPull) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.LTime != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.LTime))
|
|
}
|
|
if len(m.Networks) > 0 {
|
|
for _, e := range m.Networks {
|
|
l = e.Size()
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
}
|
|
l = len(m.NodeName)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TableEvent) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.Type))
|
|
}
|
|
if m.LTime != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.LTime))
|
|
}
|
|
l = len(m.NodeName)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
l = len(m.NetworkID)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
l = len(m.TableName)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BulkSyncMessage) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.LTime != 0 {
|
|
n += 1 + sovNetworkdb(uint64(m.LTime))
|
|
}
|
|
if m.Unsolicited {
|
|
n += 2
|
|
}
|
|
l = len(m.NodeName)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
if len(m.Networks) > 0 {
|
|
for _, s := range m.Networks {
|
|
l = len(s)
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
}
|
|
l = len(m.Payload)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *CompoundMessage) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Messages) > 0 {
|
|
for _, e := range m.Messages {
|
|
l = e.Size()
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *CompoundMessage_SimpleMessage) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
l = len(m.Payload)
|
|
if l > 0 {
|
|
n += 1 + l + sovNetworkdb(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovNetworkdb(x uint64) (n int) {
|
|
for {
|
|
n++
|
|
x >>= 7
|
|
if x == 0 {
|
|
break
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
func sozNetworkdb(x uint64) (n int) {
|
|
return sovNetworkdb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (this *GossipMessage) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&GossipMessage{`,
|
|
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
|
|
`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *NodeEvent) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&NodeEvent{`,
|
|
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
|
|
`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
|
|
`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *NetworkEvent) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&NetworkEvent{`,
|
|
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
|
|
`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
|
|
`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
|
|
`NetworkID:` + fmt.Sprintf("%v", this.NetworkID) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *NetworkEntry) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&NetworkEntry{`,
|
|
`NetworkID:` + fmt.Sprintf("%v", this.NetworkID) + `,`,
|
|
`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
|
|
`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
|
|
`Leaving:` + fmt.Sprintf("%v", this.Leaving) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *NetworkPushPull) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&NetworkPushPull{`,
|
|
`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
|
|
`Networks:` + strings.Replace(fmt.Sprintf("%v", this.Networks), "NetworkEntry", "NetworkEntry", 1) + `,`,
|
|
`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *TableEvent) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&TableEvent{`,
|
|
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
|
|
`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
|
|
`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
|
|
`NetworkID:` + fmt.Sprintf("%v", this.NetworkID) + `,`,
|
|
`TableName:` + fmt.Sprintf("%v", this.TableName) + `,`,
|
|
`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
|
|
`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *BulkSyncMessage) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&BulkSyncMessage{`,
|
|
`LTime:` + fmt.Sprintf("%v", this.LTime) + `,`,
|
|
`Unsolicited:` + fmt.Sprintf("%v", this.Unsolicited) + `,`,
|
|
`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
|
|
`Networks:` + fmt.Sprintf("%v", this.Networks) + `,`,
|
|
`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *CompoundMessage) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&CompoundMessage{`,
|
|
`Messages:` + strings.Replace(fmt.Sprintf("%v", this.Messages), "CompoundMessage_SimpleMessage", "CompoundMessage_SimpleMessage", 1) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func (this *CompoundMessage_SimpleMessage) String() string {
|
|
if this == nil {
|
|
return "nil"
|
|
}
|
|
s := strings.Join([]string{`&CompoundMessage_SimpleMessage{`,
|
|
`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
|
|
`}`,
|
|
}, "")
|
|
return s
|
|
}
|
|
func valueToStringNetworkdb(v interface{}) string {
|
|
rv := reflect.ValueOf(v)
|
|
if rv.IsNil() {
|
|
return "nil"
|
|
}
|
|
pv := reflect.Indirect(rv).Interface()
|
|
return fmt.Sprintf("*%v", pv)
|
|
}
|
|
func (m *GossipMessage) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: GossipMessage: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GossipMessage: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Type |= (MessageType(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Data = append(m.Data[:0], data[iNdEx:postIndex]...)
|
|
if m.Data == nil {
|
|
m.Data = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NodeEvent) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: NodeEvent: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NodeEvent: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Type |= (NodeEvent_Type(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
|
|
}
|
|
m.LTime = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NodeName = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NetworkEvent) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: NetworkEvent: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NetworkEvent: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Type |= (NetworkEvent_Type(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
|
|
}
|
|
m.LTime = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NodeName = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NetworkID = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NetworkEntry) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: NetworkEntry: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NetworkEntry: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NetworkID = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
|
|
}
|
|
m.LTime = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NodeName = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Leaving", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Leaving = bool(v != 0)
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *NetworkPushPull) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: NetworkPushPull: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: NetworkPushPull: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
|
|
}
|
|
m.LTime = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Networks = append(m.Networks, &NetworkEntry{})
|
|
if err := m.Networks[len(m.Networks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NodeName = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TableEvent) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: TableEvent: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TableEvent: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Type |= (TableEvent_Type(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
|
|
}
|
|
m.LTime = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NodeName = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NetworkID", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NetworkID = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.TableName = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 6:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 7:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = append(m.Value[:0], data[iNdEx:postIndex]...)
|
|
if m.Value == nil {
|
|
m.Value = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BulkSyncMessage) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: BulkSyncMessage: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BulkSyncMessage: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LTime", wireType)
|
|
}
|
|
m.LTime = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.LTime |= (github_com_hashicorp_serf_serf.LamportTime(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Unsolicited", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Unsolicited = bool(v != 0)
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.NodeName = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Networks", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Networks = append(m.Networks, string(data[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Payload = append(m.Payload[:0], data[iNdEx:postIndex]...)
|
|
if m.Payload == nil {
|
|
m.Payload = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *CompoundMessage) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: CompoundMessage: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: CompoundMessage: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Messages = append(m.Messages, &CompoundMessage_SimpleMessage{})
|
|
if err := m.Messages[len(m.Messages)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *CompoundMessage_SimpleMessage) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: SimpleMessage: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SimpleMessage: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Payload = append(m.Payload[:0], data[iNdEx:postIndex]...)
|
|
if m.Payload == nil {
|
|
m.Payload = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipNetworkdb(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthNetworkdb
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipNetworkdb(data []byte) (n int, err error) {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
wireType := int(wire & 0x7)
|
|
switch wireType {
|
|
case 0:
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if data[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 1:
|
|
iNdEx += 8
|
|
return iNdEx, nil
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx += length
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthNetworkdb
|
|
}
|
|
return iNdEx, nil
|
|
case 3:
|
|
for {
|
|
var innerWire uint64
|
|
var start int = iNdEx
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowNetworkdb
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
innerWire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
innerWireType := int(innerWire & 0x7)
|
|
if innerWireType == 4 {
|
|
break
|
|
}
|
|
next, err := skipNetworkdb(data[start:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
iNdEx = start + next
|
|
}
|
|
return iNdEx, nil
|
|
case 4:
|
|
return iNdEx, nil
|
|
case 5:
|
|
iNdEx += 4
|
|
return iNdEx, nil
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthNetworkdb = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowNetworkdb = fmt.Errorf("proto: integer overflow")
|
|
)
|
|
|
|
var fileDescriptorNetworkdb = []byte{
|
|
// 887 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x96, 0xc1, 0x6e, 0xe3, 0x44,
|
|
0x18, 0xc7, 0xeb, 0xc4, 0x49, 0xe3, 0xaf, 0x0d, 0x1b, 0xbc, 0xdd, 0xad, 0xd7, 0x0b, 0x49, 0x31,
|
|
0xcb, 0x2a, 0x44, 0xe0, 0xa2, 0xee, 0x13, 0x24, 0xb1, 0x05, 0xd9, 0xf5, 0x3a, 0x91, 0x93, 0x14,
|
|
0x71, 0x8a, 0x9c, 0x78, 0x48, 0xac, 0x3a, 0xb6, 0x15, 0x3b, 0x45, 0x39, 0x81, 0x38, 0xad, 0x78,
|
|
0x07, 0x4e, 0xcb, 0x99, 0x07, 0xe0, 0xc0, 0x89, 0xc3, 0x8a, 0x13, 0xdc, 0x10, 0x87, 0x8a, 0xee,
|
|
0x13, 0xf0, 0x08, 0x8c, 0xc7, 0x76, 0x32, 0x4e, 0xa3, 0x5e, 0x40, 0xc0, 0xc1, 0xad, 0x67, 0xe6,
|
|
0xe7, 0xcf, 0xdf, 0xf7, 0x9f, 0xff, 0xe7, 0x09, 0xdc, 0x71, 0x51, 0xf8, 0x85, 0xb7, 0xb8, 0xb0,
|
|
0xc6, 0xb2, 0xbf, 0xf0, 0x42, 0x8f, 0xe7, 0xd6, 0x13, 0xe2, 0xd1, 0xd4, 0x9b, 0x7a, 0x64, 0xf6,
|
|
0x34, 0xba, 0x8b, 0x01, 0xa9, 0x0b, 0xe5, 0x8f, 0xbd, 0x20, 0xb0, 0xfd, 0xe7, 0x28, 0x08, 0xcc,
|
|
0x29, 0xe2, 0x1b, 0xc0, 0x86, 0x2b, 0x1f, 0x09, 0xcc, 0x09, 0x53, 0x7f, 0xe3, 0xec, 0xbe, 0xbc,
|
|
0x89, 0x98, 0x10, 0x03, 0xbc, 0x6a, 0x10, 0x86, 0xe7, 0x81, 0xb5, 0xcc, 0xd0, 0x14, 0x72, 0x98,
|
|
0x3d, 0x34, 0xc8, 0xbd, 0xf4, 0x32, 0x07, 0x9c, 0xee, 0x59, 0x48, 0xbd, 0x44, 0x6e, 0xc8, 0x7f,
|
|
0x98, 0x89, 0xf6, 0x80, 0x8a, 0xb6, 0x66, 0x64, 0x2a, 0x60, 0x07, 0x8a, 0xce, 0x28, 0xb4, 0xe7,
|
|
0x88, 0x84, 0x64, 0x5b, 0x67, 0xaf, 0xae, 0x6a, 0x7b, 0xbf, 0x5f, 0xd5, 0x1a, 0x53, 0x3b, 0x9c,
|
|
0x2d, 0xc7, 0xf2, 0xc4, 0x9b, 0x9f, 0xce, 0xcc, 0x60, 0x66, 0x4f, 0xbc, 0x85, 0x7f, 0x1a, 0xa0,
|
|
0xc5, 0xe7, 0xe4, 0x8f, 0xac, 0x99, 0x73, 0xdf, 0x5b, 0x84, 0x03, 0xfc, 0xa4, 0x51, 0x70, 0xa2,
|
|
0x7f, 0xfc, 0x43, 0xe0, 0x5c, 0xfc, 0x8a, 0x91, 0x6b, 0xe2, 0x68, 0x79, 0x1c, 0x8d, 0x33, 0x4a,
|
|
0xd1, 0x84, 0x8e, 0xc7, 0xd2, 0x97, 0xc0, 0x46, 0x6f, 0xe5, 0xdf, 0x83, 0xfd, 0x8e, 0x7e, 0xde,
|
|
0xd4, 0x3a, 0x4a, 0x65, 0x4f, 0x14, 0xbe, 0xf9, 0xf6, 0xe4, 0x68, 0x9d, 0x56, 0xb4, 0xde, 0x71,
|
|
0x2f, 0x4d, 0xc7, 0xb6, 0xf8, 0x1a, 0xb0, 0x4f, 0xbb, 0x1d, 0xbd, 0xc2, 0x88, 0xf7, 0x30, 0xf3,
|
|
0x66, 0x86, 0x79, 0xea, 0xd9, 0x2e, 0xff, 0x0e, 0x14, 0x34, 0xb5, 0x79, 0xae, 0x56, 0x72, 0xe2,
|
|
0x7d, 0x4c, 0xf0, 0x19, 0x42, 0x43, 0xe6, 0x25, 0x12, 0x0f, 0x5f, 0xbc, 0xac, 0xee, 0xfd, 0xf0,
|
|
0x5d, 0x95, 0xbc, 0x58, 0xba, 0xce, 0xc1, 0xa1, 0x1e, 0x6b, 0x11, 0x0b, 0xf5, 0x51, 0x46, 0xa8,
|
|
0xb7, 0x68, 0xa1, 0x28, 0xec, 0x3f, 0xd0, 0x8a, 0xff, 0x00, 0x20, 0x49, 0x66, 0x64, 0x5b, 0x02,
|
|
0x1b, 0xad, 0xb6, 0xca, 0xaf, 0xaf, 0x6a, 0x5c, 0x92, 0x58, 0x47, 0x31, 0x52, 0x97, 0x75, 0x2c,
|
|
0xe9, 0x05, 0x93, 0x48, 0x5b, 0xa7, 0xa5, 0x7d, 0x88, 0x45, 0x39, 0xa6, 0x0b, 0xa1, 0xd5, 0x95,
|
|
0xd6, 0xea, 0xc6, 0x3b, 0xb0, 0x85, 0x11, 0x81, 0x1f, 0x6d, 0x04, 0x7e, 0x80, 0xa1, 0x7b, 0xdb,
|
|
0xd0, 0x2e, 0x8d, 0x7f, 0x64, 0x36, 0x1a, 0xbb, 0xe1, 0x62, 0xb5, 0x55, 0x09, 0x73, 0x7b, 0x25,
|
|
0xff, 0x9a, 0xbe, 0x02, 0xec, 0x3b, 0x38, 0x7b, 0xdb, 0x9d, 0x12, 0x71, 0x4b, 0x46, 0x3a, 0x94,
|
|
0xbe, 0x67, 0xe0, 0x4e, 0x92, 0x5a, 0x6f, 0x19, 0xcc, 0x7a, 0x4b, 0xc7, 0xa1, 0xb2, 0x62, 0xfe,
|
|
0x6e, 0x56, 0x4f, 0xa0, 0x94, 0x54, 0x1b, 0xe0, 0x12, 0xf3, 0xf5, 0x83, 0xb3, 0xe3, 0x1d, 0xb6,
|
|
0x8b, 0x94, 0x33, 0xd6, 0xe0, 0xed, 0x6d, 0xf5, 0x73, 0x1e, 0x60, 0x60, 0x8e, 0x9d, 0xa4, 0xf9,
|
|
0xe5, 0x8c, 0xa7, 0x45, 0x2a, 0xf8, 0x06, 0xfa, 0xdf, 0x3b, 0x9a, 0x7f, 0x1b, 0x20, 0x8c, 0xd2,
|
|
0x8d, 0x63, 0x15, 0x48, 0x2c, 0x8e, 0xcc, 0x90, 0x60, 0x15, 0xc8, 0x5f, 0xa0, 0x95, 0x50, 0x24,
|
|
0xf3, 0xd1, 0x2d, 0x7f, 0x04, 0x05, 0x6c, 0xec, 0x25, 0x12, 0xf6, 0xc9, 0x67, 0x31, 0x1e, 0x44,
|
|
0x9b, 0x19, 0x37, 0xc6, 0x63, 0xba, 0x31, 0x88, 0x99, 0x37, 0x6a, 0xd0, 0x6d, 0xf1, 0x08, 0x8a,
|
|
0x6d, 0x43, 0x6d, 0x0e, 0xd4, 0xb4, 0x31, 0xb2, 0x58, 0x7b, 0x81, 0xcc, 0x10, 0x45, 0xd4, 0xb0,
|
|
0xa7, 0x44, 0x54, 0x6e, 0x17, 0x35, 0xf4, 0xad, 0x84, 0x52, 0x54, 0x4d, 0xc5, 0x54, 0x7e, 0x17,
|
|
0xa5, 0x20, 0x07, 0x85, 0xdb, 0xed, 0xf3, 0x2b, 0x76, 0x5f, 0x6b, 0xe9, 0x5c, 0xf4, 0x57, 0xee,
|
|
0x24, 0x3d, 0x1c, 0xfe, 0x41, 0xf7, 0x9d, 0xc0, 0xc1, 0xd2, 0x0d, 0x3c, 0xc7, 0x9e, 0xd8, 0x21,
|
|
0xb2, 0xc8, 0x8e, 0x97, 0x0c, 0x7a, 0xea, 0xf6, 0x3d, 0x14, 0x29, 0xf3, 0xb2, 0xd8, 0xbc, 0x1c,
|
|
0xe5, 0x51, 0xdc, 0x51, 0xbe, 0xb9, 0x72, 0x3c, 0xd3, 0x22, 0xdb, 0x75, 0x68, 0xa4, 0x43, 0xe9,
|
|
0x6b, 0x5c, 0x53, 0xdb, 0xc3, 0xb9, 0x2c, 0x5d, 0x2b, 0xad, 0x49, 0x81, 0xd2, 0x3c, 0xbe, 0x0d,
|
|
0x70, 0x55, 0x51, 0x1b, 0xd4, 0x29, 0xa7, 0x6e, 0xd1, 0x72, 0xdf, 0x9e, 0xfb, 0x0e, 0x4a, 0x46,
|
|
0xc6, 0xfa, 0x49, 0xf1, 0x7d, 0x28, 0x67, 0x96, 0xa2, 0x24, 0x7a, 0x49, 0x12, 0x4c, 0x26, 0x89,
|
|
0xc6, 0x4f, 0x39, 0x38, 0xa0, 0xce, 0x52, 0xfe, 0x5d, 0xda, 0x10, 0xe4, 0xf8, 0xa0, 0x56, 0x53,
|
|
0x37, 0xc8, 0x50, 0xd6, 0xd5, 0xc1, 0xa7, 0x5d, 0xe3, 0xd9, 0x48, 0x3d, 0x57, 0xf5, 0x01, 0x36,
|
|
0x05, 0xf9, 0xa8, 0x52, 0x68, 0xe6, 0x3c, 0x69, 0xc0, 0xc1, 0xa0, 0xd9, 0xd2, 0xd4, 0x84, 0x4e,
|
|
0x3e, 0x9b, 0x14, 0x4d, 0xf5, 0xe9, 0x63, 0xe0, 0x7a, 0xc3, 0xfe, 0x27, 0xa3, 0xde, 0x50, 0xd3,
|
|
0xb0, 0x41, 0x8e, 0x31, 0x79, 0x97, 0x22, 0xd7, 0xdf, 0x1e, 0xcc, 0xb5, 0x86, 0xda, 0xb3, 0x51,
|
|
0xff, 0x33, 0xbd, 0x5d, 0x61, 0x6f, 0x70, 0xa9, 0x59, 0xf0, 0xa9, 0x5a, 0x6a, 0x77, 0x9f, 0xf7,
|
|
0xba, 0x43, 0x5d, 0xa9, 0x14, 0x6e, 0x60, 0xa9, 0xa2, 0xf8, 0x84, 0x00, 0xbd, 0xab, 0xa4, 0x19,
|
|
0x16, 0x63, 0x63, 0xd2, 0xf5, 0xa4, 0x87, 0xa8, 0x78, 0x37, 0x31, 0x26, 0x2d, 0x5b, 0x4b, 0xf8,
|
|
0xed, 0xba, 0xba, 0xf7, 0xe7, 0x75, 0x95, 0xf9, 0xea, 0x75, 0x95, 0x79, 0x85, 0xaf, 0x5f, 0xf0,
|
|
0xf5, 0x07, 0xbe, 0xc6, 0x45, 0xf2, 0xd3, 0xe6, 0xc9, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x21,
|
|
0x78, 0x72, 0xc3, 0x0e, 0x09, 0x00, 0x00,
|
|
}
|