github.com/leonlxy/hyperledger@v1.0.0-alpha.0.20170427033203-34922035d248/protos/gossip/message.pb.go

// Code generated by protoc-gen-go.
// source: gossip/message.proto
// DO NOT EDIT!

/*
Package gossip is a generated protocol buffer package.

It is generated from these files:
	gossip/message.proto

It has these top-level messages:
	Envelope
	SecretEnvelope
	Secret
	GossipMessage
	StateInfo
	StateInfoSnapshot
	StateInfoPullRequest
	ConnEstablish
	PeerIdentity
	DataRequest
	GossipHello
	DataUpdate
	DataDigest
	DataMessage
	Payload
	AliveMessage
	LeadershipMessage
	PeerTime
	MembershipRequest
	MembershipResponse
	Member
	Empty
	RemoteStateRequest
	RemoteStateResponse
*/
package gossip

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// 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.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type PullMsgType int32

const (
	PullMsgType_UNDEFINED    PullMsgType = 0
	PullMsgType_BLOCK_MSG    PullMsgType = 1
	PullMsgType_IDENTITY_MSG PullMsgType = 2
)

var PullMsgType_name = map[int32]string{
	0: "UNDEFINED",
	1: "BLOCK_MSG",
	2: "IDENTITY_MSG",
}
var PullMsgType_value = map[string]int32{
	"UNDEFINED":    0,
	"BLOCK_MSG":    1,
	"IDENTITY_MSG": 2,
}

func (x PullMsgType) String() string {
	return proto.EnumName(PullMsgType_name, int32(x))
}
func (PullMsgType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

type GossipMessage_Tag int32

const (
	GossipMessage_UNDEFINED    GossipMessage_Tag = 0
	GossipMessage_EMPTY        GossipMessage_Tag = 1
	GossipMessage_ORG_ONLY     GossipMessage_Tag = 2
	GossipMessage_CHAN_ONLY    GossipMessage_Tag = 3
	GossipMessage_CHAN_AND_ORG GossipMessage_Tag = 4
	GossipMessage_CHAN_OR_ORG  GossipMessage_Tag = 5
)

var GossipMessage_Tag_name = map[int32]string{
	0: "UNDEFINED",
	1: "EMPTY",
	2: "ORG_ONLY",
	3: "CHAN_ONLY",
	4: "CHAN_AND_ORG",
	5: "CHAN_OR_ORG",
}
var GossipMessage_Tag_value = map[string]int32{
	"UNDEFINED":    0,
	"EMPTY":        1,
	"ORG_ONLY":     2,
	"CHAN_ONLY":    3,
	"CHAN_AND_ORG": 4,
	"CHAN_OR_ORG":  5,
}

func (x GossipMessage_Tag) String() string {
	return proto.EnumName(GossipMessage_Tag_name, int32(x))
}
func (GossipMessage_Tag) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} }

// Envelope contains a marshalled
// GossipMessage and a signature over it.
// It may also contain a SecretEnvelope
// which is a marshalled Secret
type Envelope struct {
	Payload        []byte          `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Signature      []byte          `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	SecretEnvelope *SecretEnvelope `protobuf:"bytes,3,opt,name=secretEnvelope" json:"secretEnvelope,omitempty"`
}

func (m *Envelope) Reset()                    { *m = Envelope{} }
func (m *Envelope) String() string            { return proto.CompactTextString(m) }
func (*Envelope) ProtoMessage()               {}
func (*Envelope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *Envelope) GetSecretEnvelope() *SecretEnvelope {
	if m != nil {
		return m.SecretEnvelope
	}
	return nil
}

// SecretEnvelope is a marshalled Secret
// and a signature over it.
// The signature should be validated by the peer
// that signed the Envelope the SecretEnvelope
// came with
type SecretEnvelope struct {
	Payload   []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
}

func (m *SecretEnvelope) Reset()                    { *m = SecretEnvelope{} }
func (m *SecretEnvelope) String() string            { return proto.CompactTextString(m) }
func (*SecretEnvelope) ProtoMessage()               {}
func (*SecretEnvelope) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

// Secret is an entity that might be omitted
// from an Envelope when the remote peer that is receiving
// the Envelope shouldn't know the secret's content.
type Secret struct {
	// Types that are valid to be assigned to Content:
	//	*Secret_InternalEndpoint
	Content isSecret_Content `protobuf_oneof:"content"`
}

func (m *Secret) Reset()                    { *m = Secret{} }
func (m *Secret) String() string            { return proto.CompactTextString(m) }
func (*Secret) ProtoMessage()               {}
func (*Secret) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

type isSecret_Content interface {
	isSecret_Content()
}

type Secret_InternalEndpoint struct {
	InternalEndpoint string `protobuf:"bytes,1,opt,name=internalEndpoint,oneof"`
}

func (*Secret_InternalEndpoint) isSecret_Content() {}

func (m *Secret) GetContent() isSecret_Content {
	if m != nil {
		return m.Content
	}
	return nil
}

func (m *Secret) GetInternalEndpoint() string {
	if x, ok := m.GetContent().(*Secret_InternalEndpoint); ok {
		return x.InternalEndpoint
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Secret) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Secret_OneofMarshaler, _Secret_OneofUnmarshaler, _Secret_OneofSizer, []interface{}{
		(*Secret_InternalEndpoint)(nil),
	}
}

func _Secret_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Secret)
	// content
	switch x := m.Content.(type) {
	case *Secret_InternalEndpoint:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.InternalEndpoint)
	case nil:
	default:
		return fmt.Errorf("Secret.Content has unexpected type %T", x)
	}
	return nil
}

func _Secret_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Secret)
	switch tag {
	case 1: // content.internalEndpoint
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Content = &Secret_InternalEndpoint{x}
		return true, err
	default:
		return false, nil
	}
}

func _Secret_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Secret)
	// content
	switch x := m.Content.(type) {
	case *Secret_InternalEndpoint:
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.InternalEndpoint)))
		n += len(x.InternalEndpoint)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// GossipMessage defines the message sent in a gossip network
type GossipMessage struct {
	// used mainly for testing, but will might be used in the future
	// for ensuring message delivery by acking
	Nonce uint64 `protobuf:"varint,1,opt,name=nonce" json:"nonce,omitempty"`
	// The channel of the message.
	// Some GossipMessages may set this to nil, because
	// they are cross-channels but some may not
	Channel []byte `protobuf:"bytes,2,opt,name=channel,proto3" json:"channel,omitempty"`
	// determines to which peers it is allowed
	// to forward the message
	Tag GossipMessage_Tag `protobuf:"varint,3,opt,name=tag,enum=gossip.GossipMessage_Tag" json:"tag,omitempty"`
	// Types that are valid to be assigned to Content:
	//	*GossipMessage_AliveMsg
	//	*GossipMessage_MemReq
	//	*GossipMessage_MemRes
	//	*GossipMessage_DataMsg
	//	*GossipMessage_Hello
	//	*GossipMessage_DataDig
	//	*GossipMessage_DataReq
	//	*GossipMessage_DataUpdate
	//	*GossipMessage_Empty
	//	*GossipMessage_Conn
	//	*GossipMessage_StateInfo
	//	*GossipMessage_StateSnapshot
	//	*GossipMessage_StateInfoPullReq
	//	*GossipMessage_StateRequest
	//	*GossipMessage_StateResponse
	//	*GossipMessage_LeadershipMsg
	//	*GossipMessage_PeerIdentity
	Content isGossipMessage_Content `protobuf_oneof:"content"`
}

func (m *GossipMessage) Reset()                    { *m = GossipMessage{} }
func (m *GossipMessage) String() string            { return proto.CompactTextString(m) }
func (*GossipMessage) ProtoMessage()               {}
func (*GossipMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

type isGossipMessage_Content interface {
	isGossipMessage_Content()
}

type GossipMessage_AliveMsg struct {
	AliveMsg *AliveMessage `protobuf:"bytes,5,opt,name=alive_msg,json=aliveMsg,oneof"`
}
type GossipMessage_MemReq struct {
	MemReq *MembershipRequest `protobuf:"bytes,6,opt,name=mem_req,json=memReq,oneof"`
}
type GossipMessage_MemRes struct {
	MemRes *MembershipResponse `protobuf:"bytes,7,opt,name=mem_res,json=memRes,oneof"`
}
type GossipMessage_DataMsg struct {
	DataMsg *DataMessage `protobuf:"bytes,8,opt,name=data_msg,json=dataMsg,oneof"`
}
type GossipMessage_Hello struct {
	Hello *GossipHello `protobuf:"bytes,9,opt,name=hello,oneof"`
}
type GossipMessage_DataDig struct {
	DataDig *DataDigest `protobuf:"bytes,10,opt,name=data_dig,json=dataDig,oneof"`
}
type GossipMessage_DataReq struct {
	DataReq *DataRequest `protobuf:"bytes,11,opt,name=data_req,json=dataReq,oneof"`
}
type GossipMessage_DataUpdate struct {
	DataUpdate *DataUpdate `protobuf:"bytes,12,opt,name=data_update,json=dataUpdate,oneof"`
}
type GossipMessage_Empty struct {
	Empty *Empty `protobuf:"bytes,13,opt,name=empty,oneof"`
}
type GossipMessage_Conn struct {
	Conn *ConnEstablish `protobuf:"bytes,14,opt,name=conn,oneof"`
}
type GossipMessage_StateInfo struct {
	StateInfo *StateInfo `protobuf:"bytes,15,opt,name=state_info,json=stateInfo,oneof"`
}
type GossipMessage_StateSnapshot struct {
	StateSnapshot *StateInfoSnapshot `protobuf:"bytes,16,opt,name=state_snapshot,json=stateSnapshot,oneof"`
}
type GossipMessage_StateInfoPullReq struct {
	StateInfoPullReq *StateInfoPullRequest `protobuf:"bytes,17,opt,name=state_info_pull_req,json=stateInfoPullReq,oneof"`
}
type GossipMessage_StateRequest struct {
	StateRequest *RemoteStateRequest `protobuf:"bytes,18,opt,name=state_request,json=stateRequest,oneof"`
}
type GossipMessage_StateResponse struct {
	StateResponse *RemoteStateResponse `protobuf:"bytes,19,opt,name=state_response,json=stateResponse,oneof"`
}
type GossipMessage_LeadershipMsg struct {
	LeadershipMsg *LeadershipMessage `protobuf:"bytes,20,opt,name=leadership_msg,json=leadershipMsg,oneof"`
}
type GossipMessage_PeerIdentity struct {
	PeerIdentity *PeerIdentity `protobuf:"bytes,21,opt,name=peer_identity,json=peerIdentity,oneof"`
}

func (*GossipMessage_AliveMsg) isGossipMessage_Content()         {}
func (*GossipMessage_MemReq) isGossipMessage_Content()           {}
func (*GossipMessage_MemRes) isGossipMessage_Content()           {}
func (*GossipMessage_DataMsg) isGossipMessage_Content()          {}
func (*GossipMessage_Hello) isGossipMessage_Content()            {}
func (*GossipMessage_DataDig) isGossipMessage_Content()          {}
func (*GossipMessage_DataReq) isGossipMessage_Content()          {}
func (*GossipMessage_DataUpdate) isGossipMessage_Content()       {}
func (*GossipMessage_Empty) isGossipMessage_Content()            {}
func (*GossipMessage_Conn) isGossipMessage_Content()             {}
func (*GossipMessage_StateInfo) isGossipMessage_Content()        {}
func (*GossipMessage_StateSnapshot) isGossipMessage_Content()    {}
func (*GossipMessage_StateInfoPullReq) isGossipMessage_Content() {}
func (*GossipMessage_StateRequest) isGossipMessage_Content()     {}
func (*GossipMessage_StateResponse) isGossipMessage_Content()    {}
func (*GossipMessage_LeadershipMsg) isGossipMessage_Content()    {}
func (*GossipMessage_PeerIdentity) isGossipMessage_Content()     {}

func (m *GossipMessage) GetContent() isGossipMessage_Content {
	if m != nil {
		return m.Content
	}
	return nil
}

func (m *GossipMessage) GetAliveMsg() *AliveMessage {
	if x, ok := m.GetContent().(*GossipMessage_AliveMsg); ok {
		return x.AliveMsg
	}
	return nil
}

func (m *GossipMessage) GetMemReq() *MembershipRequest {
	if x, ok := m.GetContent().(*GossipMessage_MemReq); ok {
		return x.MemReq
	}
	return nil
}

func (m *GossipMessage) GetMemRes() *MembershipResponse {
	if x, ok := m.GetContent().(*GossipMessage_MemRes); ok {
		return x.MemRes
	}
	return nil
}

func (m *GossipMessage) GetDataMsg() *DataMessage {
	if x, ok := m.GetContent().(*GossipMessage_DataMsg); ok {
		return x.DataMsg
	}
	return nil
}

func (m *GossipMessage) GetHello() *GossipHello {
	if x, ok := m.GetContent().(*GossipMessage_Hello); ok {
		return x.Hello
	}
	return nil
}

func (m *GossipMessage) GetDataDig() *DataDigest {
	if x, ok := m.GetContent().(*GossipMessage_DataDig); ok {
		return x.DataDig
	}
	return nil
}

func (m *GossipMessage) GetDataReq() *DataRequest {
	if x, ok := m.GetContent().(*GossipMessage_DataReq); ok {
		return x.DataReq
	}
	return nil
}

func (m *GossipMessage) GetDataUpdate() *DataUpdate {
	if x, ok := m.GetContent().(*GossipMessage_DataUpdate); ok {
		return x.DataUpdate
	}
	return nil
}

func (m *GossipMessage) GetEmpty() *Empty {
	if x, ok := m.GetContent().(*GossipMessage_Empty); ok {
		return x.Empty
	}
	return nil
}

func (m *GossipMessage) GetConn() *ConnEstablish {
	if x, ok := m.GetContent().(*GossipMessage_Conn); ok {
		return x.Conn
	}
	return nil
}

func (m *GossipMessage) GetStateInfo() *StateInfo {
	if x, ok := m.GetContent().(*GossipMessage_StateInfo); ok {
		return x.StateInfo
	}
	return nil
}

func (m *GossipMessage) GetStateSnapshot() *StateInfoSnapshot {
	if x, ok := m.GetContent().(*GossipMessage_StateSnapshot); ok {
		return x.StateSnapshot
	}
	return nil
}

func (m *GossipMessage) GetStateInfoPullReq() *StateInfoPullRequest {
	if x, ok := m.GetContent().(*GossipMessage_StateInfoPullReq); ok {
		return x.StateInfoPullReq
	}
	return nil
}

func (m *GossipMessage) GetStateRequest() *RemoteStateRequest {
	if x, ok := m.GetContent().(*GossipMessage_StateRequest); ok {
		return x.StateRequest
	}
	return nil
}

func (m *GossipMessage) GetStateResponse() *RemoteStateResponse {
	if x, ok := m.GetContent().(*GossipMessage_StateResponse); ok {
		return x.StateResponse
	}
	return nil
}

func (m *GossipMessage) GetLeadershipMsg() *LeadershipMessage {
	if x, ok := m.GetContent().(*GossipMessage_LeadershipMsg); ok {
		return x.LeadershipMsg
	}
	return nil
}

func (m *GossipMessage) GetPeerIdentity() *PeerIdentity {
	if x, ok := m.GetContent().(*GossipMessage_PeerIdentity); ok {
		return x.PeerIdentity
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*GossipMessage) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _GossipMessage_OneofMarshaler, _GossipMessage_OneofUnmarshaler, _GossipMessage_OneofSizer, []interface{}{
		(*GossipMessage_AliveMsg)(nil),
		(*GossipMessage_MemReq)(nil),
		(*GossipMessage_MemRes)(nil),
		(*GossipMessage_DataMsg)(nil),
		(*GossipMessage_Hello)(nil),
		(*GossipMessage_DataDig)(nil),
		(*GossipMessage_DataReq)(nil),
		(*GossipMessage_DataUpdate)(nil),
		(*GossipMessage_Empty)(nil),
		(*GossipMessage_Conn)(nil),
		(*GossipMessage_StateInfo)(nil),
		(*GossipMessage_StateSnapshot)(nil),
		(*GossipMessage_StateInfoPullReq)(nil),
		(*GossipMessage_StateRequest)(nil),
		(*GossipMessage_StateResponse)(nil),
		(*GossipMessage_LeadershipMsg)(nil),
		(*GossipMessage_PeerIdentity)(nil),
	}
}

func _GossipMessage_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*GossipMessage)
	// content
	switch x := m.Content.(type) {
	case *GossipMessage_AliveMsg:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.AliveMsg); err != nil {
			return err
		}
	case *GossipMessage_MemReq:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MemReq); err != nil {
			return err
		}
	case *GossipMessage_MemRes:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MemRes); err != nil {
			return err
		}
	case *GossipMessage_DataMsg:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DataMsg); err != nil {
			return err
		}
	case *GossipMessage_Hello:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Hello); err != nil {
			return err
		}
	case *GossipMessage_DataDig:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DataDig); err != nil {
			return err
		}
	case *GossipMessage_DataReq:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DataReq); err != nil {
			return err
		}
	case *GossipMessage_DataUpdate:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DataUpdate); err != nil {
			return err
		}
	case *GossipMessage_Empty:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Empty); err != nil {
			return err
		}
	case *GossipMessage_Conn:
		b.EncodeVarint(14<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Conn); err != nil {
			return err
		}
	case *GossipMessage_StateInfo:
		b.EncodeVarint(15<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StateInfo); err != nil {
			return err
		}
	case *GossipMessage_StateSnapshot:
		b.EncodeVarint(16<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StateSnapshot); err != nil {
			return err
		}
	case *GossipMessage_StateInfoPullReq:
		b.EncodeVarint(17<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StateInfoPullReq); err != nil {
			return err
		}
	case *GossipMessage_StateRequest:
		b.EncodeVarint(18<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StateRequest); err != nil {
			return err
		}
	case *GossipMessage_StateResponse:
		b.EncodeVarint(19<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StateResponse); err != nil {
			return err
		}
	case *GossipMessage_LeadershipMsg:
		b.EncodeVarint(20<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeadershipMsg); err != nil {
			return err
		}
	case *GossipMessage_PeerIdentity:
		b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PeerIdentity); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("GossipMessage.Content has unexpected type %T", x)
	}
	return nil
}

func _GossipMessage_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*GossipMessage)
	switch tag {
	case 5: // content.alive_msg
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(AliveMessage)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_AliveMsg{msg}
		return true, err
	case 6: // content.mem_req
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MembershipRequest)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_MemReq{msg}
		return true, err
	case 7: // content.mem_res
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MembershipResponse)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_MemRes{msg}
		return true, err
	case 8: // content.data_msg
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DataMessage)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_DataMsg{msg}
		return true, err
	case 9: // content.hello
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(GossipHello)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_Hello{msg}
		return true, err
	case 10: // content.data_dig
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DataDigest)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_DataDig{msg}
		return true, err
	case 11: // content.data_req
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DataRequest)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_DataReq{msg}
		return true, err
	case 12: // content.data_update
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DataUpdate)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_DataUpdate{msg}
		return true, err
	case 13: // content.empty
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Empty)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_Empty{msg}
		return true, err
	case 14: // content.conn
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConnEstablish)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_Conn{msg}
		return true, err
	case 15: // content.state_info
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StateInfo)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_StateInfo{msg}
		return true, err
	case 16: // content.state_snapshot
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StateInfoSnapshot)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_StateSnapshot{msg}
		return true, err
	case 17: // content.state_info_pull_req
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StateInfoPullRequest)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_StateInfoPullReq{msg}
		return true, err
	case 18: // content.state_request
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RemoteStateRequest)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_StateRequest{msg}
		return true, err
	case 19: // content.state_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RemoteStateResponse)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_StateResponse{msg}
		return true, err
	case 20: // content.leadership_msg
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LeadershipMessage)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_LeadershipMsg{msg}
		return true, err
	case 21: // content.peer_identity
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(PeerIdentity)
		err := b.DecodeMessage(msg)
		m.Content = &GossipMessage_PeerIdentity{msg}
		return true, err
	default:
		return false, nil
	}
}

func _GossipMessage_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*GossipMessage)
	// content
	switch x := m.Content.(type) {
	case *GossipMessage_AliveMsg:
		s := proto.Size(x.AliveMsg)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_MemReq:
		s := proto.Size(x.MemReq)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_MemRes:
		s := proto.Size(x.MemRes)
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_DataMsg:
		s := proto.Size(x.DataMsg)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_Hello:
		s := proto.Size(x.Hello)
		n += proto.SizeVarint(9<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_DataDig:
		s := proto.Size(x.DataDig)
		n += proto.SizeVarint(10<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_DataReq:
		s := proto.Size(x.DataReq)
		n += proto.SizeVarint(11<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_DataUpdate:
		s := proto.Size(x.DataUpdate)
		n += proto.SizeVarint(12<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_Empty:
		s := proto.Size(x.Empty)
		n += proto.SizeVarint(13<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_Conn:
		s := proto.Size(x.Conn)
		n += proto.SizeVarint(14<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_StateInfo:
		s := proto.Size(x.StateInfo)
		n += proto.SizeVarint(15<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_StateSnapshot:
		s := proto.Size(x.StateSnapshot)
		n += proto.SizeVarint(16<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_StateInfoPullReq:
		s := proto.Size(x.StateInfoPullReq)
		n += proto.SizeVarint(17<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_StateRequest:
		s := proto.Size(x.StateRequest)
		n += proto.SizeVarint(18<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_StateResponse:
		s := proto.Size(x.StateResponse)
		n += proto.SizeVarint(19<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_LeadershipMsg:
		s := proto.Size(x.LeadershipMsg)
		n += proto.SizeVarint(20<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *GossipMessage_PeerIdentity:
		s := proto.Size(x.PeerIdentity)
		n += proto.SizeVarint(21<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// StateInfo is used for a peer to relay its state information
// to other peers
type StateInfo struct {
	Metadata  []byte    `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	Timestamp *PeerTime `protobuf:"bytes,2,opt,name=timestamp" json:"timestamp,omitempty"`
	PkiId     []byte    `protobuf:"bytes,3,opt,name=pki_id,json=pkiId,proto3" json:"pki_id,omitempty"`
	// channelMAC is an authentication code that proves
	// that the peer that sent this message knows
	// the name of the channel.
	// The channel name that this message relates to
	// can only be computed by a peer that has joined
	// the channel
	ChannelMAC []byte `protobuf:"bytes,4,opt,name=channelMAC,proto3" json:"channelMAC,omitempty"`
}

func (m *StateInfo) Reset()                    { *m = StateInfo{} }
func (m *StateInfo) String() string            { return proto.CompactTextString(m) }
func (*StateInfo) ProtoMessage()               {}
func (*StateInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *StateInfo) GetTimestamp() *PeerTime {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

// StateInfoSnapshot is an aggregation of StateInfo messages
type StateInfoSnapshot struct {
	Elements []*Envelope `protobuf:"bytes,1,rep,name=elements" json:"elements,omitempty"`
}

func (m *StateInfoSnapshot) Reset()                    { *m = StateInfoSnapshot{} }
func (m *StateInfoSnapshot) String() string            { return proto.CompactTextString(m) }
func (*StateInfoSnapshot) ProtoMessage()               {}
func (*StateInfoSnapshot) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *StateInfoSnapshot) GetElements() []*Envelope {
	if m != nil {
		return m.Elements
	}
	return nil
}

// StateInfoPullRequest is used to fetch a StateInfoSnapshot
// from a remote peer
type StateInfoPullRequest struct {
	// channelMAC is an authentication code that proves
	// that the peer that sent this message knows
	// the name of the channel.
	// The channel name that this message relates to
	// can only be computed by a peer that has joined
	// the channel
	ChannelMAC []byte `protobuf:"bytes,1,opt,name=channelMAC,proto3" json:"channelMAC,omitempty"`
}

func (m *StateInfoPullRequest) Reset()                    { *m = StateInfoPullRequest{} }
func (m *StateInfoPullRequest) String() string            { return proto.CompactTextString(m) }
func (*StateInfoPullRequest) ProtoMessage()               {}
func (*StateInfoPullRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

// ConnEstablish is the message used for the gossip handshake
// Whenever a peer connects to another peer, it handshakes
// with it by sending this message that proves its identity
type ConnEstablish struct {
	PkiId []byte `protobuf:"bytes,1,opt,name=pki_id,json=pkiId,proto3" json:"pki_id,omitempty"`
	Cert  []byte `protobuf:"bytes,2,opt,name=cert,proto3" json:"cert,omitempty"`
	Hash  []byte `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash,omitempty"`
}

func (m *ConnEstablish) Reset()                    { *m = ConnEstablish{} }
func (m *ConnEstablish) String() string            { return proto.CompactTextString(m) }
func (*ConnEstablish) ProtoMessage()               {}
func (*ConnEstablish) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }

// PeerIdentity defines the identity of the peer
// Used to make other peers learn of the identity
// of a certain peer
type PeerIdentity struct {
	PkiId    []byte `protobuf:"bytes,1,opt,name=pki_id,json=pkiId,proto3" json:"pki_id,omitempty"`
	Cert     []byte `protobuf:"bytes,2,opt,name=cert,proto3" json:"cert,omitempty"`
	Metadata []byte `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
}

func (m *PeerIdentity) Reset()                    { *m = PeerIdentity{} }
func (m *PeerIdentity) String() string            { return proto.CompactTextString(m) }
func (*PeerIdentity) ProtoMessage()               {}
func (*PeerIdentity) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }

// DataRequest is a message used for a peer to request
// certain data blocks from a remote peer
type DataRequest struct {
	Nonce   uint64      `protobuf:"varint,1,opt,name=nonce" json:"nonce,omitempty"`
	Digests []string    `protobuf:"bytes,2,rep,name=digests" json:"digests,omitempty"`
	MsgType PullMsgType `protobuf:"varint,3,opt,name=msg_type,json=msgType,enum=gossip.PullMsgType" json:"msg_type,omitempty"`
}

func (m *DataRequest) Reset()                    { *m = DataRequest{} }
func (m *DataRequest) String() string            { return proto.CompactTextString(m) }
func (*DataRequest) ProtoMessage()               {}
func (*DataRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }

// GossipHello is the message that is used for the peer to initiate
// a pull round with another peer
type GossipHello struct {
	Nonce    uint64      `protobuf:"varint,1,opt,name=nonce" json:"nonce,omitempty"`
	Metadata []byte      `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	MsgType  PullMsgType `protobuf:"varint,3,opt,name=msg_type,json=msgType,enum=gossip.PullMsgType" json:"msg_type,omitempty"`
}

func (m *GossipHello) Reset()                    { *m = GossipHello{} }
func (m *GossipHello) String() string            { return proto.CompactTextString(m) }
func (*GossipHello) ProtoMessage()               {}
func (*GossipHello) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }

// DataUpdate is the the final message in the pull phase
// sent from the receiver to the initiator
type DataUpdate struct {
	Nonce   uint64      `protobuf:"varint,1,opt,name=nonce" json:"nonce,omitempty"`
	Data    []*Envelope `protobuf:"bytes,2,rep,name=data" json:"data,omitempty"`
	MsgType PullMsgType `protobuf:"varint,3,opt,name=msg_type,json=msgType,enum=gossip.PullMsgType" json:"msg_type,omitempty"`
}

func (m *DataUpdate) Reset()                    { *m = DataUpdate{} }
func (m *DataUpdate) String() string            { return proto.CompactTextString(m) }
func (*DataUpdate) ProtoMessage()               {}
func (*DataUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }

func (m *DataUpdate) GetData() []*Envelope {
	if m != nil {
		return m.Data
	}
	return nil
}

// DataDigest is the message sent from the receiver peer
// to the initator peer and contains the data items it has
type DataDigest struct {
	Nonce   uint64      `protobuf:"varint,1,opt,name=nonce" json:"nonce,omitempty"`
	Digests []string    `protobuf:"bytes,2,rep,name=digests" json:"digests,omitempty"`
	MsgType PullMsgType `protobuf:"varint,3,opt,name=msg_type,json=msgType,enum=gossip.PullMsgType" json:"msg_type,omitempty"`
}

func (m *DataDigest) Reset()                    { *m = DataDigest{} }
func (m *DataDigest) String() string            { return proto.CompactTextString(m) }
func (*DataDigest) ProtoMessage()               {}
func (*DataDigest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }

// DataMessage is the message that contains a block
type DataMessage struct {
	Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
}

func (m *DataMessage) Reset()                    { *m = DataMessage{} }
func (m *DataMessage) String() string            { return proto.CompactTextString(m) }
func (*DataMessage) ProtoMessage()               {}
func (*DataMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }

func (m *DataMessage) GetPayload() *Payload {
	if m != nil {
		return m.Payload
	}
	return nil
}

// Payload contains a block
type Payload struct {
	SeqNum uint64 `protobuf:"varint,1,opt,name=seq_num,json=seqNum" json:"seq_num,omitempty"`
	Hash   string `protobuf:"bytes,2,opt,name=hash" json:"hash,omitempty"`
	Data   []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *Payload) Reset()                    { *m = Payload{} }
func (m *Payload) String() string            { return proto.CompactTextString(m) }
func (*Payload) ProtoMessage()               {}
func (*Payload) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }

// AliveMessage is sent to inform remote peers
// of a peer's existence and activity
type AliveMessage struct {
	Membership *Member   `protobuf:"bytes,1,opt,name=membership" json:"membership,omitempty"`
	Timestamp  *PeerTime `protobuf:"bytes,2,opt,name=timestamp" json:"timestamp,omitempty"`
	Identity   []byte    `protobuf:"bytes,4,opt,name=identity,proto3" json:"identity,omitempty"`
}

func (m *AliveMessage) Reset()                    { *m = AliveMessage{} }
func (m *AliveMessage) String() string            { return proto.CompactTextString(m) }
func (*AliveMessage) ProtoMessage()               {}
func (*AliveMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }

func (m *AliveMessage) GetMembership() *Member {
	if m != nil {
		return m.Membership
	}
	return nil
}

func (m *AliveMessage) GetTimestamp() *PeerTime {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

// Leadership Message is sent during leader election to inform
// remote peers about intent of peer to proclaim itself as leader
type LeadershipMessage struct {
	PkiId         []byte    `protobuf:"bytes,1,opt,name=pki_id,json=pkiId,proto3" json:"pki_id,omitempty"`
	Timestamp     *PeerTime `protobuf:"bytes,2,opt,name=timestamp" json:"timestamp,omitempty"`
	IsDeclaration bool      `protobuf:"varint,3,opt,name=is_declaration,json=isDeclaration" json:"is_declaration,omitempty"`
}

func (m *LeadershipMessage) Reset()                    { *m = LeadershipMessage{} }
func (m *LeadershipMessage) String() string            { return proto.CompactTextString(m) }
func (*LeadershipMessage) ProtoMessage()               {}
func (*LeadershipMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }

func (m *LeadershipMessage) GetTimestamp() *PeerTime {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

// PeerTime defines the logical time of a peer's life
type PeerTime struct {
	IncNumber uint64 `protobuf:"varint,1,opt,name=inc_number,json=incNumber" json:"inc_number,omitempty"`
	SeqNum    uint64 `protobuf:"varint,2,opt,name=seq_num,json=seqNum" json:"seq_num,omitempty"`
}

func (m *PeerTime) Reset()                    { *m = PeerTime{} }
func (m *PeerTime) String() string            { return proto.CompactTextString(m) }
func (*PeerTime) ProtoMessage()               {}
func (*PeerTime) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }

// MembershipRequest is used to ask membership information
// from a remote peer
type MembershipRequest struct {
	SelfInformation *Envelope `protobuf:"bytes,1,opt,name=self_information,json=selfInformation" json:"self_information,omitempty"`
	Known           [][]byte  `protobuf:"bytes,2,rep,name=known,proto3" json:"known,omitempty"`
}

func (m *MembershipRequest) Reset()                    { *m = MembershipRequest{} }
func (m *MembershipRequest) String() string            { return proto.CompactTextString(m) }
func (*MembershipRequest) ProtoMessage()               {}
func (*MembershipRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }

func (m *MembershipRequest) GetSelfInformation() *Envelope {
	if m != nil {
		return m.SelfInformation
	}
	return nil
}

// MembershipResponse is used for replying to MembershipRequests
type MembershipResponse struct {
	Alive []*Envelope `protobuf:"bytes,1,rep,name=alive" json:"alive,omitempty"`
	Dead  []*Envelope `protobuf:"bytes,2,rep,name=dead" json:"dead,omitempty"`
}

func (m *MembershipResponse) Reset()                    { *m = MembershipResponse{} }
func (m *MembershipResponse) String() string            { return proto.CompactTextString(m) }
func (*MembershipResponse) ProtoMessage()               {}
func (*MembershipResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }

func (m *MembershipResponse) GetAlive() []*Envelope {
	if m != nil {
		return m.Alive
	}
	return nil
}

func (m *MembershipResponse) GetDead() []*Envelope {
	if m != nil {
		return m.Dead
	}
	return nil
}

// Member holds membership-related information
// about a peer
type Member struct {
	Endpoint string `protobuf:"bytes,1,opt,name=endpoint" json:"endpoint,omitempty"`
	Metadata []byte `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	PkiId    []byte `protobuf:"bytes,3,opt,name=pki_id,json=pkiId,proto3" json:"pki_id,omitempty"`
}

func (m *Member) Reset()                    { *m = Member{} }
func (m *Member) String() string            { return proto.CompactTextString(m) }
func (*Member) ProtoMessage()               {}
func (*Member) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }

// Empty is used for pinging and in tests
type Empty struct {
}

func (m *Empty) Reset()                    { *m = Empty{} }
func (m *Empty) String() string            { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage()               {}
func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }

// RemoteStateRequest is used to ask a set of blocks
// from a remote peer
type RemoteStateRequest struct {
	StartSeqNum uint64 `protobuf:"varint,1,opt,name=start_seq_num,json=startSeqNum" json:"start_seq_num,omitempty"`
	EndSeqNum   uint64 `protobuf:"varint,2,opt,name=end_seq_num,json=endSeqNum" json:"end_seq_num,omitempty"`
}

func (m *RemoteStateRequest) Reset()                    { *m = RemoteStateRequest{} }
func (m *RemoteStateRequest) String() string            { return proto.CompactTextString(m) }
func (*RemoteStateRequest) ProtoMessage()               {}
func (*RemoteStateRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }

// RemoteStateResponse is used to send a set of blocks
// to a remote peer
type RemoteStateResponse struct {
	Payloads []*Payload `protobuf:"bytes,1,rep,name=payloads" json:"payloads,omitempty"`
}

func (m *RemoteStateResponse) Reset()                    { *m = RemoteStateResponse{} }
func (m *RemoteStateResponse) String() string            { return proto.CompactTextString(m) }
func (*RemoteStateResponse) ProtoMessage()               {}
func (*RemoteStateResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }

func (m *RemoteStateResponse) GetPayloads() []*Payload {
	if m != nil {
		return m.Payloads
	}
	return nil
}

func init() {
	proto.RegisterType((*Envelope)(nil), "gossip.Envelope")
	proto.RegisterType((*SecretEnvelope)(nil), "gossip.SecretEnvelope")
	proto.RegisterType((*Secret)(nil), "gossip.Secret")
	proto.RegisterType((*GossipMessage)(nil), "gossip.GossipMessage")
	proto.RegisterType((*StateInfo)(nil), "gossip.StateInfo")
	proto.RegisterType((*StateInfoSnapshot)(nil), "gossip.StateInfoSnapshot")
	proto.RegisterType((*StateInfoPullRequest)(nil), "gossip.StateInfoPullRequest")
	proto.RegisterType((*ConnEstablish)(nil), "gossip.ConnEstablish")
	proto.RegisterType((*PeerIdentity)(nil), "gossip.PeerIdentity")
	proto.RegisterType((*DataRequest)(nil), "gossip.DataRequest")
	proto.RegisterType((*GossipHello)(nil), "gossip.GossipHello")
	proto.RegisterType((*DataUpdate)(nil), "gossip.DataUpdate")
	proto.RegisterType((*DataDigest)(nil), "gossip.DataDigest")
	proto.RegisterType((*DataMessage)(nil), "gossip.DataMessage")
	proto.RegisterType((*Payload)(nil), "gossip.Payload")
	proto.RegisterType((*AliveMessage)(nil), "gossip.AliveMessage")
	proto.RegisterType((*LeadershipMessage)(nil), "gossip.LeadershipMessage")
	proto.RegisterType((*PeerTime)(nil), "gossip.PeerTime")
	proto.RegisterType((*MembershipRequest)(nil), "gossip.MembershipRequest")
	proto.RegisterType((*MembershipResponse)(nil), "gossip.MembershipResponse")
	proto.RegisterType((*Member)(nil), "gossip.Member")
	proto.RegisterType((*Empty)(nil), "gossip.Empty")
	proto.RegisterType((*RemoteStateRequest)(nil), "gossip.RemoteStateRequest")
	proto.RegisterType((*RemoteStateResponse)(nil), "gossip.RemoteStateResponse")
	proto.RegisterEnum("gossip.PullMsgType", PullMsgType_name, PullMsgType_value)
	proto.RegisterEnum("gossip.GossipMessage_Tag", GossipMessage_Tag_name, GossipMessage_Tag_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion3

// Client API for Gossip service

type GossipClient interface {
	// GossipStream is the gRPC stream used for sending and receiving messages
	GossipStream(ctx context.Context, opts ...grpc.CallOption) (Gossip_GossipStreamClient, error)
	// Ping is used to probe a remote peer's aliveness
	Ping(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
}

type gossipClient struct {
	cc *grpc.ClientConn
}

func NewGossipClient(cc *grpc.ClientConn) GossipClient {
	return &gossipClient{cc}
}

func (c *gossipClient) GossipStream(ctx context.Context, opts ...grpc.CallOption) (Gossip_GossipStreamClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Gossip_serviceDesc.Streams[0], c.cc, "/gossip.Gossip/GossipStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &gossipGossipStreamClient{stream}
	return x, nil
}

type Gossip_GossipStreamClient interface {
	Send(*Envelope) error
	Recv() (*Envelope, error)
	grpc.ClientStream
}

type gossipGossipStreamClient struct {
	grpc.ClientStream
}

func (x *gossipGossipStreamClient) Send(m *Envelope) error {
	return x.ClientStream.SendMsg(m)
}

func (x *gossipGossipStreamClient) Recv() (*Envelope, error) {
	m := new(Envelope)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *gossipClient) Ping(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := grpc.Invoke(ctx, "/gossip.Gossip/Ping", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Gossip service

type GossipServer interface {
	// GossipStream is the gRPC stream used for sending and receiving messages
	GossipStream(Gossip_GossipStreamServer) error
	// Ping is used to probe a remote peer's aliveness
	Ping(context.Context, *Empty) (*Empty, error)
}

func RegisterGossipServer(s *grpc.Server, srv GossipServer) {
	s.RegisterService(&_Gossip_serviceDesc, srv)
}

func _Gossip_GossipStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(GossipServer).GossipStream(&gossipGossipStreamServer{stream})
}

type Gossip_GossipStreamServer interface {
	Send(*Envelope) error
	Recv() (*Envelope, error)
	grpc.ServerStream
}

type gossipGossipStreamServer struct {
	grpc.ServerStream
}

func (x *gossipGossipStreamServer) Send(m *Envelope) error {
	return x.ServerStream.SendMsg(m)
}

func (x *gossipGossipStreamServer) Recv() (*Envelope, error) {
	m := new(Envelope)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Gossip_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GossipServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gossip.Gossip/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GossipServer).Ping(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _Gossip_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gossip.Gossip",
	HandlerType: (*GossipServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _Gossip_Ping_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GossipStream",
			Handler:       _Gossip_GossipStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: fileDescriptor0,
}

func init() { proto.RegisterFile("gossip/message.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 1352 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x57, 0xdd, 0x6f, 0xe3, 0x44,
	0x10, 0x8f, 0x9b, 0x4f, 0x4f, 0x3e, 0x9a, 0x6e, 0x7b, 0x60, 0xca, 0x71, 0xaa, 0x2c, 0xee, 0x54,
	0xe8, 0x91, 0x9e, 0x7a, 0x80, 0x4e, 0x3a, 0x81, 0x94, 0x36, 0xa1, 0x09, 0x5c, 0xd2, 0xca, 0xcd,
	0x09, 0x8e, 0x17, 0x6b, 0x13, 0x6f, 0x1d, 0x73, 0xf6, 0xda, 0xf5, 0x6e, 0x0e, 0xfa, 0x08, 0x8f,
	0x3c, 0xf0, 0xcc, 0x9f, 0x8b, 0xbc, 0x6b, 0x3b, 0x76, 0xdd, 0x9e, 0xd4, 0x93, 0x78, 0xf3, 0x7c,
	0xfc, 0x66, 0x66, 0x67, 0x67, 0x67, 0xc6, 0xb0, 0x63, 0xfb, 0x8c, 0x39, 0xc1, 0xa1, 0x47, 0x18,
	0xc3, 0x36, 0xe9, 0x05, 0xa1, 0xcf, 0x7d, 0x54, 0x93, 0x5c, 0xfd, 0x2f, 0x05, 0x1a, 0x43, 0xfa,
	0x8e, 0xb8, 0x7e, 0x40, 0x90, 0x06, 0xf5, 0x00, 0x5f, 0xbb, 0x3e, 0xb6, 0x34, 0x65, 0x4f, 0xd9,
	0x6f, 0x19, 0x09, 0x89, 0x1e, 0x82, 0xca, 0x1c, 0x9b, 0x62, 0xbe, 0x0a, 0x89, 0xb6, 0x21, 0x64,
	0x6b, 0x06, 0xfa, 0x1e, 0x3a, 0x8c, 0x2c, 0x42, 0xc2, 0x13, 0x4b, 0x5a, 0x79, 0x4f, 0xd9, 0x6f,
	0x1e, 0x7d, 0xd4, 0x93, 0x5e, 0x7a, 0x17, 0x39, 0xa9, 0x71, 0x43, 0x5b, 0x1f, 0x41, 0x27, 0xaf,
	0xf1, 0xa1, 0x91, 0xe8, 0x7d, 0xa8, 0x49, 0x4b, 0xe8, 0x29, 0x74, 0x1d, 0xca, 0x49, 0x48, 0xb1,
	0x3b, 0xa4, 0x56, 0xe0, 0x3b, 0x94, 0x0b, 0x53, 0xea, 0xa8, 0x64, 0x14, 0x24, 0xc7, 0x2a, 0xd4,
	0x17, 0x3e, 0xe5, 0x84, 0x72, 0xfd, 0x5f, 0x15, 0xda, 0xa7, 0x22, 0xec, 0x89, 0xcc, 0x18, 0xda,
	0x81, 0x2a, 0xf5, 0xe9, 0x82, 0x08, 0x7c, 0xc5, 0x90, 0x44, 0x14, 0xe2, 0x62, 0x89, 0x29, 0x25,
	0x6e, 0x1c, 0x46, 0x42, 0xa2, 0x03, 0x28, 0x73, 0x6c, 0x8b, 0x1c, 0x74, 0x8e, 0x3e, 0x49, 0x72,
	0x90, 0xb3, 0xd9, 0x9b, 0x61, 0xdb, 0x88, 0xb4, 0xd0, 0x73, 0x50, 0xb1, 0xeb, 0xbc, 0x23, 0xa6,
	0xc7, 0x6c, 0xad, 0x2a, 0xd2, 0xb6, 0x93, 0x40, 0xfa, 0x91, 0x20, 0x46, 0x8c, 0x4a, 0x46, 0x43,
	0x28, 0x4e, 0x98, 0x8d, 0xbe, 0x86, 0xba, 0x47, 0x3c, 0x33, 0x24, 0x57, 0x5a, 0x4d, 0x40, 0x52,
	0x2f, 0x13, 0xe2, 0xcd, 0x49, 0xc8, 0x96, 0x4e, 0x60, 0x90, 0xab, 0x15, 0x61, 0x7c, 0x54, 0x32,
	0x6a, 0x1e, 0xf1, 0x0c, 0x72, 0x85, 0xbe, 0x49, 0x50, 0x4c, 0xab, 0x0b, 0xd4, 0xee, 0x6d, 0x28,
	0x16, 0xf8, 0x94, 0x91, 0x14, 0xc6, 0xd0, 0x33, 0x68, 0x58, 0x98, 0x63, 0x11, 0x60, 0x43, 0xe0,
	0xb6, 0x13, 0xdc, 0x00, 0x73, 0xbc, 0x8e, 0xaf, 0x1e, 0xa9, 0x45, 0xe1, 0x1d, 0x40, 0x75, 0x49,
	0x5c, 0xd7, 0xd7, 0xd4, 0xbc, 0xba, 0x4c, 0xc1, 0x28, 0x12, 0x8d, 0x4a, 0x86, 0xd4, 0x41, 0x87,
	0xb1, 0x79, 0xcb, 0xb1, 0x35, 0x10, 0xfa, 0x28, 0x6b, 0x7e, 0xe0, 0xd8, 0xf2, 0x14, 0xc2, 0xfa,
	0xc0, 0xb1, 0xd3, 0x78, 0xa2, 0xd3, 0x37, 0x8b, 0xf1, 0xac, 0xcf, 0x2d, 0x10, 0xf2, 0xe0, 0x4d,
	0x81, 0x58, 0x05, 0x16, 0xe6, 0x44, 0x6b, 0x15, 0xbd, 0xbc, 0x16, 0x92, 0x51, 0xc9, 0x00, 0x2b,
	0xa5, 0xd0, 0x63, 0xa8, 0x12, 0x2f, 0xe0, 0xd7, 0x5a, 0x5b, 0x00, 0xda, 0x09, 0x60, 0x18, 0x31,
	0xa3, 0x03, 0x08, 0x29, 0x3a, 0x80, 0xca, 0xc2, 0xa7, 0x54, 0xeb, 0x08, 0xad, 0x07, 0x89, 0xd6,
	0x89, 0x4f, 0xe9, 0x90, 0x71, 0x3c, 0x77, 0x1d, 0xb6, 0x1c, 0x95, 0x0c, 0xa1, 0x84, 0x8e, 0x00,
	0x18, 0xc7, 0x9c, 0x98, 0x0e, 0xbd, 0xf4, 0xb5, 0x4d, 0x01, 0xd9, 0x4a, 0x9f, 0x49, 0x24, 0x19,
	0xd3, 0xcb, 0x28, 0x3b, 0x2a, 0x4b, 0x08, 0x74, 0x0c, 0x1d, 0x89, 0x61, 0x14, 0x07, 0x6c, 0xe9,
	0x73, 0xad, 0x9b, 0xbf, 0xf4, 0x14, 0x77, 0x11, 0x2b, 0x8c, 0x4a, 0x46, 0x5b, 0x40, 0x12, 0x06,
	0x9a, 0xc0, 0xf6, 0xda, 0xaf, 0x19, 0xac, 0x5c, 0x57, 0xe4, 0x6f, 0x4b, 0x18, 0x7a, 0x58, 0x30,
	0x74, 0xbe, 0x72, 0xdd, 0x75, 0x22, 0xbb, 0xec, 0x06, 0x1f, 0xf5, 0x41, 0xda, 0x8f, 0x8c, 0x44,
	0x4a, 0x1a, 0xca, 0x17, 0x94, 0x41, 0x3c, 0x9f, 0x13, 0x61, 0x6e, 0x6d, 0xa6, 0xc5, 0x32, 0x34,
	0x1a, 0x24, 0xa7, 0x0a, 0xe3, 0x92, 0xd3, 0xb6, 0x85, 0x8d, 0x4f, 0x6f, 0xb5, 0x91, 0x56, 0x65,
	0x9b, 0x65, 0x19, 0x51, 0x6e, 0x5c, 0x82, 0x2d, 0x59, 0xbc, 0xa2, 0x44, 0x77, 0xf2, 0xb9, 0x79,
	0x95, 0x4a, 0xd7, 0x85, 0xda, 0x5e, 0x43, 0xa2, 0x72, 0x7d, 0x09, 0xed, 0x80, 0x90, 0xd0, 0x74,
	0x2c, 0x42, 0xb9, 0xc3, 0xaf, 0xb5, 0x07, 0xf9, 0x67, 0x78, 0x4e, 0x48, 0x38, 0x8e, 0x65, 0xd1,
	0x31, 0x82, 0x0c, 0xad, 0x9b, 0x50, 0x9e, 0x61, 0x1b, 0xb5, 0x41, 0x7d, 0x3d, 0x1d, 0x0c, 0x7f,
	0x18, 0x4f, 0x87, 0x83, 0x6e, 0x09, 0xa9, 0x50, 0x1d, 0x4e, 0xce, 0x67, 0x6f, 0xba, 0x0a, 0x6a,
	0x41, 0xe3, 0xcc, 0x38, 0x35, 0xcf, 0xa6, 0xaf, 0xde, 0x74, 0x37, 0x22, 0xbd, 0x93, 0x51, 0x7f,
	0x2a, 0xc9, 0x32, 0xea, 0x42, 0x4b, 0x90, 0xfd, 0xe9, 0xc0, 0x3c, 0x33, 0x4e, 0xbb, 0x15, 0xb4,
	0x09, 0x4d, 0xa9, 0x60, 0x08, 0x46, 0x35, 0xdb, 0x9a, 0xfe, 0x51, 0x40, 0x4d, 0xaf, 0x08, 0xed,
	0x42, 0xc3, 0x23, 0x1c, 0x47, 0x05, 0x1b, 0x37, 0xc9, 0x94, 0x46, 0x3d, 0x50, 0xb9, 0xe3, 0x11,
	0xc6, 0xb1, 0x17, 0x88, 0xf6, 0xd4, 0x3c, 0xea, 0x66, 0x8f, 0x33, 0x73, 0x3c, 0x62, 0xac, 0x55,
	0xd0, 0x03, 0xa8, 0x05, 0x6f, 0x1d, 0xd3, 0xb1, 0x44, 0xd7, 0x6a, 0x19, 0xd5, 0xe0, 0xad, 0x33,
	0xb6, 0xd0, 0x23, 0x80, 0xb8, 0xa9, 0x4d, 0xfa, 0x27, 0x5a, 0x45, 0x88, 0x32, 0x1c, 0xbd, 0x0f,
	0x5b, 0x85, 0xda, 0x43, 0x4f, 0xa1, 0x41, 0x5c, 0xe2, 0x11, 0xca, 0x99, 0xa6, 0xec, 0x95, 0xb3,
	0xae, 0xd3, 0x09, 0x90, 0x6a, 0xe8, 0xdf, 0xc2, 0xce, 0x6d, 0x55, 0x77, 0xc3, 0xb5, 0x52, 0x70,
	0x3d, 0x85, 0x76, 0xee, 0x85, 0x65, 0x8e, 0xa0, 0x64, 0x8f, 0x80, 0xa0, 0xb2, 0x20, 0x21, 0x8f,
	0x7b, 0xb4, 0xf8, 0x8e, 0x78, 0x4b, 0xcc, 0x96, 0xf1, 0x59, 0xc5, 0xb7, 0xfe, 0x1a, 0x5a, 0xd9,
	0x7b, 0xbe, 0x8f, 0xb9, 0xec, 0x45, 0x94, 0xf3, 0x17, 0xa1, 0x7b, 0xd0, 0xcc, 0x34, 0xa5, 0xbb,
	0x47, 0x89, 0x25, 0xda, 0x1c, 0xd3, 0x36, 0xf6, 0xca, 0xfb, 0xaa, 0x91, 0x90, 0xa8, 0x07, 0x0d,
	0x8f, 0xd9, 0x26, 0xbf, 0x8e, 0x67, 0x6a, 0x67, 0xdd, 0xeb, 0xa2, 0x64, 0x4d, 0x98, 0x3d, 0xbb,
	0x0e, 0x88, 0x51, 0xf7, 0xe4, 0x87, 0xee, 0x43, 0x33, 0xd3, 0x64, 0xef, 0x70, 0x97, 0x8d, 0x77,
	0xa3, 0x50, 0x38, 0xf7, 0x73, 0xf8, 0x07, 0xc0, 0xba, 0x7f, 0xde, 0xe1, 0xef, 0x73, 0xa8, 0xc4,
	0xbe, 0x6e, 0x2f, 0x86, 0xca, 0x07, 0x79, 0x76, 0xa5, 0x67, 0x39, 0x1f, 0xfe, 0xf7, 0xc4, 0xbe,
	0x90, 0xf7, 0x98, 0xac, 0x04, 0x5f, 0xe4, 0xf7, 0x93, 0xe6, 0xd1, 0x66, 0x8a, 0x96, 0xec, 0x74,
	0x61, 0xd1, 0x7f, 0x84, 0x7a, 0xcc, 0x43, 0x1f, 0x43, 0x9d, 0x91, 0x2b, 0x93, 0xae, 0xbc, 0x38,
	0xcc, 0x1a, 0x23, 0x57, 0xd3, 0x95, 0x97, 0x16, 0x64, 0x74, 0x1b, 0xaa, 0x2c, 0xc8, 0x88, 0x97,
	0xa9, 0x28, 0xf1, 0xad, 0xff, 0xad, 0x40, 0x2b, 0xbb, 0x14, 0xa0, 0x1e, 0x80, 0x97, 0xce, 0xee,
	0x38, 0x94, 0x4e, 0x7e, 0xaa, 0x1b, 0x19, 0x8d, 0x7b, 0xf7, 0x85, 0x5d, 0x68, 0xa4, 0x5d, 0x51,
	0x3e, 0xff, 0x94, 0xd6, 0xff, 0x54, 0x60, 0xab, 0xd0, 0x5d, 0xef, 0x7a, 0x37, 0xf7, 0x75, 0xfc,
	0x18, 0x3a, 0x0e, 0x33, 0x2d, 0xb2, 0x70, 0x71, 0x88, 0xb9, 0xe3, 0x53, 0x91, 0x87, 0x86, 0xd1,
	0x76, 0xd8, 0x60, 0xcd, 0xd4, 0x8f, 0xa1, 0x91, 0xa0, 0xd1, 0x67, 0x00, 0x0e, 0x5d, 0x44, 0xd9,
	0x9d, 0x93, 0x30, 0x4e, 0xb0, 0xea, 0xd0, 0xc5, 0x54, 0x30, 0xb2, 0xc9, 0xdf, 0xc8, 0x26, 0x5f,
	0xbf, 0x84, 0xad, 0xc2, 0xd6, 0x84, 0x5e, 0x42, 0x97, 0x11, 0xf7, 0x52, 0x8c, 0xcb, 0xd0, 0x93,
	0x11, 0x28, 0xf9, 0xb0, 0xd3, 0xfa, 0xdd, 0x8c, 0x34, 0xc7, 0x6b, 0xc5, 0xa8, 0x18, 0xdf, 0x52,
	0xff, 0x77, 0x2a, 0x8a, 0xae, 0x65, 0x48, 0x42, 0x9f, 0x03, 0x2a, 0xee, 0x59, 0xe8, 0x09, 0x54,
	0xc5, 0x5a, 0x77, 0x67, 0xab, 0x94, 0x62, 0xf1, 0x88, 0x08, 0xb6, 0xde, 0xf3, 0x88, 0x08, 0xb6,
	0xf4, 0x9f, 0xa1, 0x26, 0x7d, 0x44, 0x37, 0x47, 0x72, 0x7b, 0xaf, 0x91, 0xd2, 0xef, 0x6d, 0x00,
	0xb7, 0x4f, 0x02, 0xbd, 0x0e, 0x55, 0xb1, 0xf6, 0xe8, 0xbf, 0x00, 0x2a, 0x0e, 0x77, 0xa4, 0x8b,
	0x7d, 0x20, 0xe4, 0x66, 0xbe, 0xbe, 0x9b, 0x82, 0x79, 0x21, 0x8b, 0xfc, 0x11, 0x34, 0x09, 0xb5,
	0xcc, 0xfc, 0x25, 0xa8, 0x84, 0x5a, 0x52, 0xae, 0x1f, 0xc3, 0xf6, 0x2d, 0x23, 0x1f, 0x1d, 0x40,
	0x23, 0x7e, 0x4a, 0xc9, 0x38, 0x29, 0xbc, 0xb5, 0x54, 0xe1, 0xcb, 0xef, 0xa0, 0x99, 0x79, 0xbe,
	0x37, 0xa7, 0x72, 0x1b, 0xd4, 0xe3, 0x57, 0x67, 0x27, 0x3f, 0x99, 0x93, 0x8b, 0xd3, 0xae, 0x12,
	0x0d, 0xdf, 0xf1, 0x60, 0x38, 0x9d, 0x8d, 0x67, 0x6f, 0x04, 0x67, 0xe3, 0xe8, 0x37, 0xa8, 0xc9,
	0xf6, 0x89, 0x5e, 0x40, 0x4b, 0x7e, 0x5d, 0xf0, 0x90, 0x60, 0x0f, 0x15, 0x12, 0xbe, 0x5b, 0xe0,
	0xe8, 0xa5, 0x7d, 0xe5, 0x99, 0x82, 0x9e, 0x40, 0xe5, 0xdc, 0xa1, 0x36, 0xca, 0xaf, 0x8b, 0xbb,
	0x79, 0x52, 0x2f, 0x1d, 0x7f, 0xf5, 0xeb, 0x81, 0xed, 0xf0, 0xe5, 0x6a, 0xde, 0x5b, 0xf8, 0xde,
	0xe1, 0xf2, 0x3a, 0x20, 0xa1, 0x4b, 0x2c, 0x9b, 0x84, 0x87, 0x97, 0x78, 0x1e, 0x3a, 0x8b, 0x43,
	0xf1, 0xa3, 0xc6, 0x0e, 0x25, 0x6c, 0x5e, 0x13, 0xe4, 0xf3, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff,
	0xd6, 0x2d, 0x62, 0x5a, 0xcf, 0x0d, 0x00, 0x00,
}