raft.pb.go

// Code generated by protoc-gen-gogo.
// source: raft.proto
// DO NOT EDIT!

package types

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

// skipping weak import gogoproto "gogoproto"

import strings "strings"
import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// StoreActionKind defines the operation to take on the store for the target of
// a storage action.
type StoreActionKind int32

const (
	StoreActionKindUnknown StoreActionKind = 0
	StoreActionKindCreate  StoreActionKind = 1
	StoreActionKindUpdate  StoreActionKind = 2
	StoreActionKindRemove  StoreActionKind = 3
)

var StoreActionKind_name = map[int32]string{
	0: "UNKNOWN",
	1: "STORE_ACTION_CREATE",
	2: "STORE_ACTION_UPDATE",
	3: "STORE_ACTION_REMOVE",
}
var StoreActionKind_value = map[string]int32{
	"UNKNOWN":             0,
	"STORE_ACTION_CREATE": 1,
	"STORE_ACTION_UPDATE": 2,
	"STORE_ACTION_REMOVE": 3,
}

func (x StoreActionKind) String() string {
	return proto.EnumName(StoreActionKind_name, int32(x))
}
func (StoreActionKind) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{0} }

// Contains one of many protobuf encoded objects to replicate
// over the raft backend with a request ID to track when the
// action is effectively applied
type InternalRaftRequest struct {
	ID     uint64         `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Action []*StoreAction `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"`
}

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

// StoreAction defines a target and operation to apply on the storage system.
type StoreAction struct {
	Action StoreActionKind `protobuf:"varint,1,opt,name=action,proto3,enum=types.StoreActionKind" json:"action,omitempty"`
	// Types that are valid to be assigned to Target:
	//	*StoreAction_Application
	//	*StoreAction_Framework
	//	*StoreAction_Version
	//	*StoreAction_Slot
	//	*StoreAction_Task
	//	*StoreAction_OfferAllocatorItem
	//	*StoreAction_Node
	Target isStoreAction_Target `protobuf_oneof:"target"`
}

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

type isStoreAction_Target interface {
	isStoreAction_Target()
	Equal(interface{}) bool
	VerboseEqual(interface{}) error
	MarshalTo([]byte) (int, error)
	Size() int
}

type StoreAction_Application struct {
	Application *Application `protobuf:"bytes,2,opt,name=application,oneof"`
}
type StoreAction_Framework struct {
	Framework *Framework `protobuf:"bytes,3,opt,name=framework,oneof"`
}
type StoreAction_Version struct {
	Version *Version `protobuf:"bytes,4,opt,name=version,oneof"`
}
type StoreAction_Slot struct {
	Slot *Slot `protobuf:"bytes,5,opt,name=slot,oneof"`
}
type StoreAction_Task struct {
	Task *Task `protobuf:"bytes,6,opt,name=task,oneof"`
}
type StoreAction_OfferAllocatorItem struct {
	OfferAllocatorItem *OfferAllocatorItem `protobuf:"bytes,7,opt,name=offerAllocatorItem,oneof"`
}
type StoreAction_Node struct {
	Node *Node `protobuf:"bytes,8,opt,name=node,oneof"`
}

func (*StoreAction_Application) isStoreAction_Target()        {}
func (*StoreAction_Framework) isStoreAction_Target()          {}
func (*StoreAction_Version) isStoreAction_Target()            {}
func (*StoreAction_Slot) isStoreAction_Target()               {}
func (*StoreAction_Task) isStoreAction_Target()               {}
func (*StoreAction_OfferAllocatorItem) isStoreAction_Target() {}
func (*StoreAction_Node) isStoreAction_Target()               {}

func (m *StoreAction) GetTarget() isStoreAction_Target {
	if m != nil {
		return m.Target
	}
	return nil
}

func (m *StoreAction) GetApplication() *Application {
	if x, ok := m.GetTarget().(*StoreAction_Application); ok {
		return x.Application
	}
	return nil
}

func (m *StoreAction) GetFramework() *Framework {
	if x, ok := m.GetTarget().(*StoreAction_Framework); ok {
		return x.Framework
	}
	return nil
}

func (m *StoreAction) GetVersion() *Version {
	if x, ok := m.GetTarget().(*StoreAction_Version); ok {
		return x.Version
	}
	return nil
}

func (m *StoreAction) GetSlot() *Slot {
	if x, ok := m.GetTarget().(*StoreAction_Slot); ok {
		return x.Slot
	}
	return nil
}

func (m *StoreAction) GetTask() *Task {
	if x, ok := m.GetTarget().(*StoreAction_Task); ok {
		return x.Task
	}
	return nil
}

func (m *StoreAction) GetOfferAllocatorItem() *OfferAllocatorItem {
	if x, ok := m.GetTarget().(*StoreAction_OfferAllocatorItem); ok {
		return x.OfferAllocatorItem
	}
	return nil
}

func (m *StoreAction) GetNode() *Node {
	if x, ok := m.GetTarget().(*StoreAction_Node); ok {
		return x.Node
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StoreAction) 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 _StoreAction_OneofMarshaler, _StoreAction_OneofUnmarshaler, _StoreAction_OneofSizer, []interface{}{
		(*StoreAction_Application)(nil),
		(*StoreAction_Framework)(nil),
		(*StoreAction_Version)(nil),
		(*StoreAction_Slot)(nil),
		(*StoreAction_Task)(nil),
		(*StoreAction_OfferAllocatorItem)(nil),
		(*StoreAction_Node)(nil),
	}
}

func _StoreAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StoreAction)
	// target
	switch x := m.Target.(type) {
	case *StoreAction_Application:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Application); err != nil {
			return err
		}
	case *StoreAction_Framework:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Framework); err != nil {
			return err
		}
	case *StoreAction_Version:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Version); err != nil {
			return err
		}
	case *StoreAction_Slot:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Slot); err != nil {
			return err
		}
	case *StoreAction_Task:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Task); err != nil {
			return err
		}
	case *StoreAction_OfferAllocatorItem:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.OfferAllocatorItem); err != nil {
			return err
		}
	case *StoreAction_Node:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Node); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("StoreAction.Target has unexpected type %T", x)
	}
	return nil
}

func _StoreAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StoreAction)
	switch tag {
	case 2: // target.application
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Application)
		err := b.DecodeMessage(msg)
		m.Target = &StoreAction_Application{msg}
		return true, err
	case 3: // target.framework
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Framework)
		err := b.DecodeMessage(msg)
		m.Target = &StoreAction_Framework{msg}
		return true, err
	case 4: // target.version
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Version)
		err := b.DecodeMessage(msg)
		m.Target = &StoreAction_Version{msg}
		return true, err
	case 5: // target.slot
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Slot)
		err := b.DecodeMessage(msg)
		m.Target = &StoreAction_Slot{msg}
		return true, err
	case 6: // target.task
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Task)
		err := b.DecodeMessage(msg)
		m.Target = &StoreAction_Task{msg}
		return true, err
	case 7: // target.offerAllocatorItem
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(OfferAllocatorItem)
		err := b.DecodeMessage(msg)
		m.Target = &StoreAction_OfferAllocatorItem{msg}
		return true, err
	case 8: // target.node
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Node)
		err := b.DecodeMessage(msg)
		m.Target = &StoreAction_Node{msg}
		return true, err
	default:
		return false, nil
	}
}

func _StoreAction_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StoreAction)
	// target
	switch x := m.Target.(type) {
	case *StoreAction_Application:
		s := proto.Size(x.Application)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StoreAction_Framework:
		s := proto.Size(x.Framework)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StoreAction_Version:
		s := proto.Size(x.Version)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StoreAction_Slot:
		s := proto.Size(x.Slot)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StoreAction_Task:
		s := proto.Size(x.Task)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StoreAction_OfferAllocatorItem:
		s := proto.Size(x.OfferAllocatorItem)
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *StoreAction_Node:
		s := proto.Size(x.Node)
		n += proto.SizeVarint(8<<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
}

type Framework struct {
	ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}

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

type Node struct {
	ID                string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	AdvertiseAddr     string            `protobuf:"bytes,2,opt,name=advertiseAddr,proto3" json:"advertiseAddr,omitempty"`
	ListenAddr        string            `protobuf:"bytes,3,opt,name=listenAddr,proto3" json:"listenAddr,omitempty"`
	RaftListenAddr    string            `protobuf:"bytes,4,opt,name=raftListenAddr,proto3" json:"raftListenAddr,omitempty"`
	RaftAdvertiseAddr string            `protobuf:"bytes,5,opt,name=raftAdvertiseAddr,proto3" json:"raftAdvertiseAddr,omitempty"`
	Status            string            `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"`
	Labels            map[string]string `protobuf:"bytes,7,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Role              string            `protobuf:"bytes,8,opt,name=role,proto3" json:"role,omitempty"`
	RaftID            uint64            `protobuf:"varint,9,opt,name=raftID,proto3" json:"raftID,omitempty"`
}

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

func init() {
	proto.RegisterType((*InternalRaftRequest)(nil), "types.InternalRaftRequest")
	proto.RegisterType((*StoreAction)(nil), "types.StoreAction")
	proto.RegisterType((*Framework)(nil), "types.Framework")
	proto.RegisterType((*Node)(nil), "types.Node")
	proto.RegisterEnum("types.StoreActionKind", StoreActionKind_name, StoreActionKind_value)
}
func (this *InternalRaftRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*InternalRaftRequest)
	if !ok {
		that2, ok := that.(InternalRaftRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *InternalRaftRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *InternalRaftRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *InternalRaftRequest but is not nil && this == nil")
	}
	if this.ID != that1.ID {
		return fmt.Errorf("ID this(%v) Not Equal that(%v)", this.ID, that1.ID)
	}
	if len(this.Action) != len(that1.Action) {
		return fmt.Errorf("Action this(%v) Not Equal that(%v)", len(this.Action), len(that1.Action))
	}
	for i := range this.Action {
		if !this.Action[i].Equal(that1.Action[i]) {
			return fmt.Errorf("Action this[%v](%v) Not Equal that[%v](%v)", i, this.Action[i], i, that1.Action[i])
		}
	}
	return nil
}
func (this *InternalRaftRequest) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*InternalRaftRequest)
	if !ok {
		that2, ok := that.(InternalRaftRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if len(this.Action) != len(that1.Action) {
		return false
	}
	for i := range this.Action {
		if !this.Action[i].Equal(that1.Action[i]) {
			return false
		}
	}
	return true
}
func (this *StoreAction) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction)
	if !ok {
		that2, ok := that.(StoreAction)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction but is not nil && this == nil")
	}
	if this.Action != that1.Action {
		return fmt.Errorf("Action this(%v) Not Equal that(%v)", this.Action, that1.Action)
	}
	if that1.Target == nil {
		if this.Target != nil {
			return fmt.Errorf("this.Target != nil && that1.Target == nil")
		}
	} else if this.Target == nil {
		return fmt.Errorf("this.Target == nil && that1.Target != nil")
	} else if err := this.Target.VerboseEqual(that1.Target); err != nil {
		return err
	}
	return nil
}
func (this *StoreAction_Application) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction_Application)
	if !ok {
		that2, ok := that.(StoreAction_Application)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction_Application")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction_Application but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction_Application but is not nil && this == nil")
	}
	if !this.Application.Equal(that1.Application) {
		return fmt.Errorf("Application this(%v) Not Equal that(%v)", this.Application, that1.Application)
	}
	return nil
}
func (this *StoreAction_Framework) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction_Framework)
	if !ok {
		that2, ok := that.(StoreAction_Framework)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction_Framework")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction_Framework but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction_Framework but is not nil && this == nil")
	}
	if !this.Framework.Equal(that1.Framework) {
		return fmt.Errorf("Framework this(%v) Not Equal that(%v)", this.Framework, that1.Framework)
	}
	return nil
}
func (this *StoreAction_Version) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction_Version)
	if !ok {
		that2, ok := that.(StoreAction_Version)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction_Version")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction_Version but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction_Version but is not nil && this == nil")
	}
	if !this.Version.Equal(that1.Version) {
		return fmt.Errorf("Version this(%v) Not Equal that(%v)", this.Version, that1.Version)
	}
	return nil
}
func (this *StoreAction_Slot) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction_Slot)
	if !ok {
		that2, ok := that.(StoreAction_Slot)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction_Slot")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction_Slot but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction_Slot but is not nil && this == nil")
	}
	if !this.Slot.Equal(that1.Slot) {
		return fmt.Errorf("Slot this(%v) Not Equal that(%v)", this.Slot, that1.Slot)
	}
	return nil
}
func (this *StoreAction_Task) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction_Task)
	if !ok {
		that2, ok := that.(StoreAction_Task)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction_Task")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction_Task but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction_Task but is not nil && this == nil")
	}
	if !this.Task.Equal(that1.Task) {
		return fmt.Errorf("Task this(%v) Not Equal that(%v)", this.Task, that1.Task)
	}
	return nil
}
func (this *StoreAction_OfferAllocatorItem) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction_OfferAllocatorItem)
	if !ok {
		that2, ok := that.(StoreAction_OfferAllocatorItem)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction_OfferAllocatorItem")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction_OfferAllocatorItem but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction_OfferAllocatorItem but is not nil && this == nil")
	}
	if !this.OfferAllocatorItem.Equal(that1.OfferAllocatorItem) {
		return fmt.Errorf("OfferAllocatorItem this(%v) Not Equal that(%v)", this.OfferAllocatorItem, that1.OfferAllocatorItem)
	}
	return nil
}
func (this *StoreAction_Node) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StoreAction_Node)
	if !ok {
		that2, ok := that.(StoreAction_Node)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StoreAction_Node")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StoreAction_Node but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StoreAction_Node but is not nil && this == nil")
	}
	if !this.Node.Equal(that1.Node) {
		return fmt.Errorf("Node this(%v) Not Equal that(%v)", this.Node, that1.Node)
	}
	return nil
}
func (this *StoreAction) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction)
	if !ok {
		that2, ok := that.(StoreAction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Action != that1.Action {
		return false
	}
	if that1.Target == nil {
		if this.Target != nil {
			return false
		}
	} else if this.Target == nil {
		return false
	} else if !this.Target.Equal(that1.Target) {
		return false
	}
	return true
}
func (this *StoreAction_Application) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction_Application)
	if !ok {
		that2, ok := that.(StoreAction_Application)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Application.Equal(that1.Application) {
		return false
	}
	return true
}
func (this *StoreAction_Framework) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction_Framework)
	if !ok {
		that2, ok := that.(StoreAction_Framework)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Framework.Equal(that1.Framework) {
		return false
	}
	return true
}
func (this *StoreAction_Version) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction_Version)
	if !ok {
		that2, ok := that.(StoreAction_Version)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Version.Equal(that1.Version) {
		return false
	}
	return true
}
func (this *StoreAction_Slot) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction_Slot)
	if !ok {
		that2, ok := that.(StoreAction_Slot)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Slot.Equal(that1.Slot) {
		return false
	}
	return true
}
func (this *StoreAction_Task) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction_Task)
	if !ok {
		that2, ok := that.(StoreAction_Task)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Task.Equal(that1.Task) {
		return false
	}
	return true
}
func (this *StoreAction_OfferAllocatorItem) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction_OfferAllocatorItem)
	if !ok {
		that2, ok := that.(StoreAction_OfferAllocatorItem)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.OfferAllocatorItem.Equal(that1.OfferAllocatorItem) {
		return false
	}
	return true
}
func (this *StoreAction_Node) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StoreAction_Node)
	if !ok {
		that2, ok := that.(StoreAction_Node)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Node.Equal(that1.Node) {
		return false
	}
	return true
}
func (this *Framework) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Framework)
	if !ok {
		that2, ok := that.(Framework)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Framework")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Framework but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Framework but is not nil && this == nil")
	}
	if this.ID != that1.ID {
		return fmt.Errorf("ID this(%v) Not Equal that(%v)", this.ID, that1.ID)
	}
	return nil
}
func (this *Framework) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Framework)
	if !ok {
		that2, ok := that.(Framework)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	return true
}
func (this *Node) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Node)
	if !ok {
		that2, ok := that.(Node)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Node")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Node but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Node but is not nil && this == nil")
	}
	if this.ID != that1.ID {
		return fmt.Errorf("ID this(%v) Not Equal that(%v)", this.ID, that1.ID)
	}
	if this.AdvertiseAddr != that1.AdvertiseAddr {
		return fmt.Errorf("AdvertiseAddr this(%v) Not Equal that(%v)", this.AdvertiseAddr, that1.AdvertiseAddr)
	}
	if this.ListenAddr != that1.ListenAddr {
		return fmt.Errorf("ListenAddr this(%v) Not Equal that(%v)", this.ListenAddr, that1.ListenAddr)
	}
	if this.RaftListenAddr != that1.RaftListenAddr {
		return fmt.Errorf("RaftListenAddr this(%v) Not Equal that(%v)", this.RaftListenAddr, that1.RaftListenAddr)
	}
	if this.RaftAdvertiseAddr != that1.RaftAdvertiseAddr {
		return fmt.Errorf("RaftAdvertiseAddr this(%v) Not Equal that(%v)", this.RaftAdvertiseAddr, that1.RaftAdvertiseAddr)
	}
	if this.Status != that1.Status {
		return fmt.Errorf("Status this(%v) Not Equal that(%v)", this.Status, that1.Status)
	}
	if len(this.Labels) != len(that1.Labels) {
		return fmt.Errorf("Labels this(%v) Not Equal that(%v)", len(this.Labels), len(that1.Labels))
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return fmt.Errorf("Labels this[%v](%v) Not Equal that[%v](%v)", i, this.Labels[i], i, that1.Labels[i])
		}
	}
	if this.Role != that1.Role {
		return fmt.Errorf("Role this(%v) Not Equal that(%v)", this.Role, that1.Role)
	}
	if this.RaftID != that1.RaftID {
		return fmt.Errorf("RaftID this(%v) Not Equal that(%v)", this.RaftID, that1.RaftID)
	}
	return nil
}
func (this *Node) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Node)
	if !ok {
		that2, ok := that.(Node)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.AdvertiseAddr != that1.AdvertiseAddr {
		return false
	}
	if this.ListenAddr != that1.ListenAddr {
		return false
	}
	if this.RaftListenAddr != that1.RaftListenAddr {
		return false
	}
	if this.RaftAdvertiseAddr != that1.RaftAdvertiseAddr {
		return false
	}
	if this.Status != that1.Status {
		return false
	}
	if len(this.Labels) != len(that1.Labels) {
		return false
	}
	for i := range this.Labels {
		if this.Labels[i] != that1.Labels[i] {
			return false
		}
	}
	if this.Role != that1.Role {
		return false
	}
	if this.RaftID != that1.RaftID {
		return false
	}
	return true
}
func (this *InternalRaftRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&types.InternalRaftRequest{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	if this.Action != nil {
		s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *StoreAction) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&types.StoreAction{")
	s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n")
	if this.Target != nil {
		s = append(s, "Target: "+fmt.Sprintf("%#v", this.Target)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *StoreAction_Application) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&types.StoreAction_Application{` +
		`Application:` + fmt.Sprintf("%#v", this.Application) + `}`}, ", ")
	return s
}
func (this *StoreAction_Framework) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&types.StoreAction_Framework{` +
		`Framework:` + fmt.Sprintf("%#v", this.Framework) + `}`}, ", ")
	return s
}
func (this *StoreAction_Version) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&types.StoreAction_Version{` +
		`Version:` + fmt.Sprintf("%#v", this.Version) + `}`}, ", ")
	return s
}
func (this *StoreAction_Slot) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&types.StoreAction_Slot{` +
		`Slot:` + fmt.Sprintf("%#v", this.Slot) + `}`}, ", ")
	return s
}
func (this *StoreAction_Task) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&types.StoreAction_Task{` +
		`Task:` + fmt.Sprintf("%#v", this.Task) + `}`}, ", ")
	return s
}
func (this *StoreAction_OfferAllocatorItem) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&types.StoreAction_OfferAllocatorItem{` +
		`OfferAllocatorItem:` + fmt.Sprintf("%#v", this.OfferAllocatorItem) + `}`}, ", ")
	return s
}
func (this *StoreAction_Node) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&types.StoreAction_Node{` +
		`Node:` + fmt.Sprintf("%#v", this.Node) + `}`}, ", ")
	return s
}
func (this *Framework) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&types.Framework{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Node) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 13)
	s = append(s, "&types.Node{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "AdvertiseAddr: "+fmt.Sprintf("%#v", this.AdvertiseAddr)+",\n")
	s = append(s, "ListenAddr: "+fmt.Sprintf("%#v", this.ListenAddr)+",\n")
	s = append(s, "RaftListenAddr: "+fmt.Sprintf("%#v", this.RaftListenAddr)+",\n")
	s = append(s, "RaftAdvertiseAddr: "+fmt.Sprintf("%#v", this.RaftAdvertiseAddr)+",\n")
	s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%#v: %#v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	if this.Labels != nil {
		s = append(s, "Labels: "+mapStringForLabels+",\n")
	}
	s = append(s, "Role: "+fmt.Sprintf("%#v", this.Role)+",\n")
	s = append(s, "RaftID: "+fmt.Sprintf("%#v", this.RaftID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringRaft(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 (m *InternalRaftRequest) 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 *InternalRaftRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.ID))
	}
	if len(m.Action) > 0 {
		for _, msg := range m.Action {
			dAtA[i] = 0x12
			i++
			i = encodeVarintRaft(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *StoreAction) 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 *StoreAction) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Action != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Action))
	}
	if m.Target != nil {
		nn1, err := m.Target.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn1
	}
	return i, nil
}

func (m *StoreAction_Application) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Application != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Application.Size()))
		n2, err := m.Application.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	return i, nil
}
func (m *StoreAction_Framework) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Framework != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Framework.Size()))
		n3, err := m.Framework.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}
func (m *StoreAction_Version) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Version != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Version.Size()))
		n4, err := m.Version.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}
func (m *StoreAction_Slot) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Slot != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Slot.Size()))
		n5, err := m.Slot.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	return i, nil
}
func (m *StoreAction_Task) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Task != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Task.Size()))
		n6, err := m.Task.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}
func (m *StoreAction_OfferAllocatorItem) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.OfferAllocatorItem != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.OfferAllocatorItem.Size()))
		n7, err := m.OfferAllocatorItem.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}
func (m *StoreAction_Node) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Node != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Node.Size()))
		n8, err := m.Node.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}
func (m *Framework) 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 *Framework) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.ID)))
		i += copy(dAtA[i:], m.ID)
	}
	return i, nil
}

func (m *Node) 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 *Node) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.ID)))
		i += copy(dAtA[i:], m.ID)
	}
	if len(m.AdvertiseAddr) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.AdvertiseAddr)))
		i += copy(dAtA[i:], m.AdvertiseAddr)
	}
	if len(m.ListenAddr) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.ListenAddr)))
		i += copy(dAtA[i:], m.ListenAddr)
	}
	if len(m.RaftListenAddr) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.RaftListenAddr)))
		i += copy(dAtA[i:], m.RaftListenAddr)
	}
	if len(m.RaftAdvertiseAddr) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.RaftAdvertiseAddr)))
		i += copy(dAtA[i:], m.RaftAdvertiseAddr)
	}
	if len(m.Status) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.Status)))
		i += copy(dAtA[i:], m.Status)
	}
	if len(m.Labels) > 0 {
		for k, _ := range m.Labels {
			dAtA[i] = 0x3a
			i++
			v := m.Labels[k]
			mapSize := 1 + len(k) + sovRaft(uint64(len(k))) + 1 + len(v) + sovRaft(uint64(len(v)))
			i = encodeVarintRaft(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintRaft(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintRaft(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if len(m.Role) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.Role)))
		i += copy(dAtA[i:], m.Role)
	}
	if m.RaftID != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.RaftID))
	}
	return i, nil
}

func encodeFixed64Raft(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 encodeFixed32Raft(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 encodeVarintRaft(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 NewPopulatedInternalRaftRequest(r randyRaft, easy bool) *InternalRaftRequest {
	this := &InternalRaftRequest{}
	this.ID = uint64(uint64(r.Uint32()))
	if r.Intn(10) != 0 {
		v1 := r.Intn(5)
		this.Action = make([]*StoreAction, v1)
		for i := 0; i < v1; i++ {
			this.Action[i] = NewPopulatedStoreAction(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedStoreAction(r randyRaft, easy bool) *StoreAction {
	this := &StoreAction{}
	this.Action = StoreActionKind([]int32{0, 1, 2, 3}[r.Intn(4)])
	oneofNumber_Target := []int32{2, 3, 4, 5, 6, 7, 8}[r.Intn(7)]
	switch oneofNumber_Target {
	case 2:
		this.Target = NewPopulatedStoreAction_Application(r, easy)
	case 3:
		this.Target = NewPopulatedStoreAction_Framework(r, easy)
	case 4:
		this.Target = NewPopulatedStoreAction_Version(r, easy)
	case 5:
		this.Target = NewPopulatedStoreAction_Slot(r, easy)
	case 6:
		this.Target = NewPopulatedStoreAction_Task(r, easy)
	case 7:
		this.Target = NewPopulatedStoreAction_OfferAllocatorItem(r, easy)
	case 8:
		this.Target = NewPopulatedStoreAction_Node(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedStoreAction_Application(r randyRaft, easy bool) *StoreAction_Application {
	this := &StoreAction_Application{}
	this.Application = NewPopulatedApplication(r, easy)
	return this
}
func NewPopulatedStoreAction_Framework(r randyRaft, easy bool) *StoreAction_Framework {
	this := &StoreAction_Framework{}
	this.Framework = NewPopulatedFramework(r, easy)
	return this
}
func NewPopulatedStoreAction_Version(r randyRaft, easy bool) *StoreAction_Version {
	this := &StoreAction_Version{}
	this.Version = NewPopulatedVersion(r, easy)
	return this
}
func NewPopulatedStoreAction_Slot(r randyRaft, easy bool) *StoreAction_Slot {
	this := &StoreAction_Slot{}
	this.Slot = NewPopulatedSlot(r, easy)
	return this
}
func NewPopulatedStoreAction_Task(r randyRaft, easy bool) *StoreAction_Task {
	this := &StoreAction_Task{}
	this.Task = NewPopulatedTask(r, easy)
	return this
}
func NewPopulatedStoreAction_OfferAllocatorItem(r randyRaft, easy bool) *StoreAction_OfferAllocatorItem {
	this := &StoreAction_OfferAllocatorItem{}
	this.OfferAllocatorItem = NewPopulatedOfferAllocatorItem(r, easy)
	return this
}
func NewPopulatedStoreAction_Node(r randyRaft, easy bool) *StoreAction_Node {
	this := &StoreAction_Node{}
	this.Node = NewPopulatedNode(r, easy)
	return this
}
func NewPopulatedFramework(r randyRaft, easy bool) *Framework {
	this := &Framework{}
	this.ID = string(randStringRaft(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedNode(r randyRaft, easy bool) *Node {
	this := &Node{}
	this.ID = string(randStringRaft(r))
	this.AdvertiseAddr = string(randStringRaft(r))
	this.ListenAddr = string(randStringRaft(r))
	this.RaftListenAddr = string(randStringRaft(r))
	this.RaftAdvertiseAddr = string(randStringRaft(r))
	this.Status = string(randStringRaft(r))
	if r.Intn(10) != 0 {
		v2 := r.Intn(10)
		this.Labels = make(map[string]string)
		for i := 0; i < v2; i++ {
			this.Labels[randStringRaft(r)] = randStringRaft(r)
		}
	}
	this.Role = string(randStringRaft(r))
	this.RaftID = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyRaft interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneRaft(r randyRaft) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringRaft(r randyRaft) string {
	v3 := r.Intn(100)
	tmps := make([]rune, v3)
	for i := 0; i < v3; i++ {
		tmps[i] = randUTF8RuneRaft(r)
	}
	return string(tmps)
}
func randUnrecognizedRaft(r randyRaft, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldRaft(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldRaft(dAtA []byte, r randyRaft, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateRaft(dAtA, uint64(key))
		v4 := r.Int63()
		if r.Intn(2) == 0 {
			v4 *= -1
		}
		dAtA = encodeVarintPopulateRaft(dAtA, uint64(v4))
	case 1:
		dAtA = encodeVarintPopulateRaft(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateRaft(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateRaft(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateRaft(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateRaft(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *InternalRaftRequest) Size() (n int) {
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovRaft(uint64(m.ID))
	}
	if len(m.Action) > 0 {
		for _, e := range m.Action {
			l = e.Size()
			n += 1 + l + sovRaft(uint64(l))
		}
	}
	return n
}

func (m *StoreAction) Size() (n int) {
	var l int
	_ = l
	if m.Action != 0 {
		n += 1 + sovRaft(uint64(m.Action))
	}
	if m.Target != nil {
		n += m.Target.Size()
	}
	return n
}

func (m *StoreAction_Application) Size() (n int) {
	var l int
	_ = l
	if m.Application != nil {
		l = m.Application.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}
func (m *StoreAction_Framework) Size() (n int) {
	var l int
	_ = l
	if m.Framework != nil {
		l = m.Framework.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}
func (m *StoreAction_Version) Size() (n int) {
	var l int
	_ = l
	if m.Version != nil {
		l = m.Version.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}
func (m *StoreAction_Slot) Size() (n int) {
	var l int
	_ = l
	if m.Slot != nil {
		l = m.Slot.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}
func (m *StoreAction_Task) Size() (n int) {
	var l int
	_ = l
	if m.Task != nil {
		l = m.Task.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}
func (m *StoreAction_OfferAllocatorItem) Size() (n int) {
	var l int
	_ = l
	if m.OfferAllocatorItem != nil {
		l = m.OfferAllocatorItem.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}
func (m *StoreAction_Node) Size() (n int) {
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}
func (m *Framework) Size() (n int) {
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}

func (m *Node) Size() (n int) {
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	l = len(m.AdvertiseAddr)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	l = len(m.ListenAddr)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	l = len(m.RaftListenAddr)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	l = len(m.RaftAdvertiseAddr)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovRaft(uint64(len(k))) + 1 + len(v) + sovRaft(uint64(len(v)))
			n += mapEntrySize + 1 + sovRaft(uint64(mapEntrySize))
		}
	}
	l = len(m.Role)
	if l > 0 {
		n += 1 + l + sovRaft(uint64(l))
	}
	if m.RaftID != 0 {
		n += 1 + sovRaft(uint64(m.RaftID))
	}
	return n
}

func sovRaft(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRaft(x uint64) (n int) {
	return sovRaft(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *InternalRaftRequest) 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 ErrIntOverflowRaft
			}
			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: InternalRaftRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InternalRaftRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Action = append(m.Action, &StoreAction{})
			if err := m.Action[len(m.Action)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StoreAction) 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 ErrIntOverflowRaft
			}
			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: StoreAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoreAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			m.Action = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Action |= (StoreActionKind(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Application", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Application{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Target = &StoreAction_Application{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Framework", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Framework{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Target = &StoreAction_Framework{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Version{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Target = &StoreAction_Version{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Slot{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Target = &StoreAction_Slot{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Task", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Task{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Target = &StoreAction_Task{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OfferAllocatorItem", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OfferAllocatorItem{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Target = &StoreAction_OfferAllocatorItem{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Node{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Target = &StoreAction_Node{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Framework) 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 ErrIntOverflowRaft
			}
			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: Framework: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Framework: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Node) 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 ErrIntOverflowRaft
			}
			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: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdvertiseAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AdvertiseAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListenAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ListenAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftListenAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RaftListenAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftAdvertiseAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RaftAdvertiseAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var stringLenmapkey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLenmapkey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLenmapkey := int(stringLenmapkey)
			if intStringLenmapkey < 0 {
				return ErrInvalidLengthRaft
			}
			postStringIndexmapkey := iNdEx + intStringLenmapkey
			if postStringIndexmapkey > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.Labels == nil {
				m.Labels = make(map[string]string)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRaft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var stringLenmapvalue uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRaft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLenmapvalue |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLenmapvalue := int(stringLenmapvalue)
				if intStringLenmapvalue < 0 {
					return ErrInvalidLengthRaft
				}
				postStringIndexmapvalue := iNdEx + intStringLenmapvalue
				if postStringIndexmapvalue > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
				iNdEx = postStringIndexmapvalue
				m.Labels[mapkey] = mapvalue
			} else {
				var mapvalue string
				m.Labels[mapkey] = mapvalue
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				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 ErrInvalidLengthRaft
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Role = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftID", wireType)
			}
			m.RaftID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RaftID |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRaft(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, ErrIntOverflowRaft
			}
			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, ErrIntOverflowRaft
				}
				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, ErrIntOverflowRaft
				}
				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, ErrInvalidLengthRaft
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowRaft
					}
					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 := skipRaft(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 (
	ErrInvalidLengthRaft = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRaft   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("raft.proto", fileDescriptorRaft) }

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