moc_lbagent_agent.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: moc_lbagent_agent.proto

package lbagent

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	common "github.com/microsoft/moc/rpc/common"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type LoadBalancerType int32

const (
	LoadBalancerType_Haproxy    LoadBalancerType = 0
	LoadBalancerType_Keepalived LoadBalancerType = 1
	LoadBalancerType_Nginx      LoadBalancerType = 2
)

var LoadBalancerType_name = map[int32]string{
	0: "Haproxy",
	1: "Keepalived",
	2: "Nginx",
}

var LoadBalancerType_value = map[string]int32{
	"Haproxy":    0,
	"Keepalived": 1,
	"Nginx":      2,
}

func (x LoadBalancerType) String() string {
	return proto.EnumName(LoadBalancerType_name, int32(x))
}

func (LoadBalancerType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f2129e850e085f66, []int{0}
}

type LoadBalancerRequest struct {
	LoadBalancers        []*LoadBalancer  `protobuf:"bytes,1,rep,name=LoadBalancers,proto3" json:"LoadBalancers,omitempty"`
	OperationType        common.Operation `protobuf:"varint,2,opt,name=OperationType,proto3,enum=moc.Operation" json:"OperationType,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

func (m *LoadBalancerRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerRequest.Unmarshal(m, b)
}
func (m *LoadBalancerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerRequest.Marshal(b, m, deterministic)
}
func (m *LoadBalancerRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerRequest.Merge(m, src)
}
func (m *LoadBalancerRequest) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerRequest.Size(m)
}
func (m *LoadBalancerRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerRequest proto.InternalMessageInfo

func (m *LoadBalancerRequest) GetLoadBalancers() []*LoadBalancer {
	if m != nil {
		return m.LoadBalancers
	}
	return nil
}

func (m *LoadBalancerRequest) GetOperationType() common.Operation {
	if m != nil {
		return m.OperationType
	}
	return common.Operation_GET
}

type LoadBalancerResponse struct {
	LoadBalancers        []*LoadBalancer     `protobuf:"bytes,1,rep,name=LoadBalancers,proto3" json:"LoadBalancers,omitempty"`
	Result               *wrappers.BoolValue `protobuf:"bytes,2,opt,name=Result,proto3" json:"Result,omitempty"`
	Error                string              `protobuf:"bytes,3,opt,name=Error,proto3" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

func (m *LoadBalancerResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerResponse.Unmarshal(m, b)
}
func (m *LoadBalancerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerResponse.Marshal(b, m, deterministic)
}
func (m *LoadBalancerResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerResponse.Merge(m, src)
}
func (m *LoadBalancerResponse) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerResponse.Size(m)
}
func (m *LoadBalancerResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerResponse proto.InternalMessageInfo

func (m *LoadBalancerResponse) GetLoadBalancers() []*LoadBalancer {
	if m != nil {
		return m.LoadBalancers
	}
	return nil
}

func (m *LoadBalancerResponse) GetResult() *wrappers.BoolValue {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *LoadBalancerResponse) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type LoadBalancingRule struct {
	FrontendPort         uint32          `protobuf:"varint,1,opt,name=frontendPort,proto3" json:"frontendPort,omitempty"`
	BackendPort          uint32          `protobuf:"varint,2,opt,name=backendPort,proto3" json:"backendPort,omitempty"`
	Protocol             common.Protocol `protobuf:"varint,3,opt,name=protocol,proto3,enum=moc.Protocol" json:"protocol,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

func (m *LoadBalancingRule) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancingRule.Unmarshal(m, b)
}
func (m *LoadBalancingRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancingRule.Marshal(b, m, deterministic)
}
func (m *LoadBalancingRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancingRule.Merge(m, src)
}
func (m *LoadBalancingRule) XXX_Size() int {
	return xxx_messageInfo_LoadBalancingRule.Size(m)
}
func (m *LoadBalancingRule) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancingRule.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancingRule proto.InternalMessageInfo

func (m *LoadBalancingRule) GetFrontendPort() uint32 {
	if m != nil {
		return m.FrontendPort
	}
	return 0
}

func (m *LoadBalancingRule) GetBackendPort() uint32 {
	if m != nil {
		return m.BackendPort
	}
	return 0
}

func (m *LoadBalancingRule) GetProtocol() common.Protocol {
	if m != nil {
		return m.Protocol
	}
	return common.Protocol_All
}

type LoadBalancer struct {
	Name                 string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Id                   string               `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Backendips           []string             `protobuf:"bytes,3,rep,name=backendips,proto3" json:"backendips,omitempty"`
	Frontendip           string               `protobuf:"bytes,4,opt,name=frontendip,proto3" json:"frontendip,omitempty"`
	Loadbalancingrules   []*LoadBalancingRule `protobuf:"bytes,5,rep,name=loadbalancingrules,proto3" json:"loadbalancingrules,omitempty"`
	Status               *common.Status       `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *LoadBalancer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancer.Unmarshal(m, b)
}
func (m *LoadBalancer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancer.Marshal(b, m, deterministic)
}
func (m *LoadBalancer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancer.Merge(m, src)
}
func (m *LoadBalancer) XXX_Size() int {
	return xxx_messageInfo_LoadBalancer.Size(m)
}
func (m *LoadBalancer) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancer.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancer proto.InternalMessageInfo

func (m *LoadBalancer) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *LoadBalancer) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *LoadBalancer) GetBackendips() []string {
	if m != nil {
		return m.Backendips
	}
	return nil
}

func (m *LoadBalancer) GetFrontendip() string {
	if m != nil {
		return m.Frontendip
	}
	return ""
}

func (m *LoadBalancer) GetLoadbalancingrules() []*LoadBalancingRule {
	if m != nil {
		return m.Loadbalancingrules
	}
	return nil
}

func (m *LoadBalancer) GetStatus() *common.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type LoadBalancerConfigRequest struct {
	Loadbalancertype     LoadBalancerType `protobuf:"varint,1,opt,name=loadbalancertype,proto3,enum=moc.lbagent.LoadBalancerType" json:"loadbalancertype,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

func (m *LoadBalancerConfigRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerConfigRequest.Unmarshal(m, b)
}
func (m *LoadBalancerConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerConfigRequest.Marshal(b, m, deterministic)
}
func (m *LoadBalancerConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerConfigRequest.Merge(m, src)
}
func (m *LoadBalancerConfigRequest) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerConfigRequest.Size(m)
}
func (m *LoadBalancerConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerConfigRequest proto.InternalMessageInfo

func (m *LoadBalancerConfigRequest) GetLoadbalancertype() LoadBalancerType {
	if m != nil {
		return m.Loadbalancertype
	}
	return LoadBalancerType_Haproxy
}

type LoadBalancerConfigResponse struct {
	Config               string   `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *LoadBalancerConfigResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerConfigResponse.Unmarshal(m, b)
}
func (m *LoadBalancerConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerConfigResponse.Marshal(b, m, deterministic)
}
func (m *LoadBalancerConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerConfigResponse.Merge(m, src)
}
func (m *LoadBalancerConfigResponse) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerConfigResponse.Size(m)
}
func (m *LoadBalancerConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerConfigResponse proto.InternalMessageInfo

func (m *LoadBalancerConfigResponse) GetConfig() string {
	if m != nil {
		return m.Config
	}
	return ""
}

type LoadBalancerPeerRequest struct {
	Peers                []string `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *LoadBalancerPeerRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerPeerRequest.Unmarshal(m, b)
}
func (m *LoadBalancerPeerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerPeerRequest.Marshal(b, m, deterministic)
}
func (m *LoadBalancerPeerRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerPeerRequest.Merge(m, src)
}
func (m *LoadBalancerPeerRequest) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerPeerRequest.Size(m)
}
func (m *LoadBalancerPeerRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerPeerRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerPeerRequest proto.InternalMessageInfo

func (m *LoadBalancerPeerRequest) GetPeers() []string {
	if m != nil {
		return m.Peers
	}
	return nil
}

type LoadBalancerPeerResponse struct {
	Peers                []string            `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"`
	Result               *wrappers.BoolValue `protobuf:"bytes,2,opt,name=Result,proto3" json:"Result,omitempty"`
	Error                string              `protobuf:"bytes,3,opt,name=Error,proto3" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

func (m *LoadBalancerPeerResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerPeerResponse.Unmarshal(m, b)
}
func (m *LoadBalancerPeerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerPeerResponse.Marshal(b, m, deterministic)
}
func (m *LoadBalancerPeerResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerPeerResponse.Merge(m, src)
}
func (m *LoadBalancerPeerResponse) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerPeerResponse.Size(m)
}
func (m *LoadBalancerPeerResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerPeerResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerPeerResponse proto.InternalMessageInfo

func (m *LoadBalancerPeerResponse) GetPeers() []string {
	if m != nil {
		return m.Peers
	}
	return nil
}

func (m *LoadBalancerPeerResponse) GetResult() *wrappers.BoolValue {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *LoadBalancerPeerResponse) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type LoadBalancerResyncRequest struct {
	LoadBalancers        []*LoadBalancer `protobuf:"bytes,1,rep,name=LoadBalancers,proto3" json:"LoadBalancers,omitempty"`
	Peers                []string        `protobuf:"bytes,2,rep,name=peers,proto3" json:"peers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

func (m *LoadBalancerResyncRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerResyncRequest.Unmarshal(m, b)
}
func (m *LoadBalancerResyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerResyncRequest.Marshal(b, m, deterministic)
}
func (m *LoadBalancerResyncRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerResyncRequest.Merge(m, src)
}
func (m *LoadBalancerResyncRequest) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerResyncRequest.Size(m)
}
func (m *LoadBalancerResyncRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerResyncRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerResyncRequest proto.InternalMessageInfo

func (m *LoadBalancerResyncRequest) GetLoadBalancers() []*LoadBalancer {
	if m != nil {
		return m.LoadBalancers
	}
	return nil
}

func (m *LoadBalancerResyncRequest) GetPeers() []string {
	if m != nil {
		return m.Peers
	}
	return nil
}

type LoadBalancerResyncResponse struct {
	LoadBalancers        []*LoadBalancer     `protobuf:"bytes,1,rep,name=LoadBalancers,proto3" json:"LoadBalancers,omitempty"`
	Peers                []string            `protobuf:"bytes,2,rep,name=peers,proto3" json:"peers,omitempty"`
	Result               *wrappers.BoolValue `protobuf:"bytes,3,opt,name=Result,proto3" json:"Result,omitempty"`
	Error                string              `protobuf:"bytes,4,opt,name=Error,proto3" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

func (m *LoadBalancerResyncResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LoadBalancerResyncResponse.Unmarshal(m, b)
}
func (m *LoadBalancerResyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LoadBalancerResyncResponse.Marshal(b, m, deterministic)
}
func (m *LoadBalancerResyncResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoadBalancerResyncResponse.Merge(m, src)
}
func (m *LoadBalancerResyncResponse) XXX_Size() int {
	return xxx_messageInfo_LoadBalancerResyncResponse.Size(m)
}
func (m *LoadBalancerResyncResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LoadBalancerResyncResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LoadBalancerResyncResponse proto.InternalMessageInfo

func (m *LoadBalancerResyncResponse) GetLoadBalancers() []*LoadBalancer {
	if m != nil {
		return m.LoadBalancers
	}
	return nil
}

func (m *LoadBalancerResyncResponse) GetPeers() []string {
	if m != nil {
		return m.Peers
	}
	return nil
}

func (m *LoadBalancerResyncResponse) GetResult() *wrappers.BoolValue {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *LoadBalancerResyncResponse) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func init() {
	proto.RegisterEnum("moc.lbagent.LoadBalancerType", LoadBalancerType_name, LoadBalancerType_value)
	proto.RegisterType((*LoadBalancerRequest)(nil), "moc.lbagent.LoadBalancerRequest")
	proto.RegisterType((*LoadBalancerResponse)(nil), "moc.lbagent.LoadBalancerResponse")
	proto.RegisterType((*LoadBalancingRule)(nil), "moc.lbagent.LoadBalancingRule")
	proto.RegisterType((*LoadBalancer)(nil), "moc.lbagent.LoadBalancer")
	proto.RegisterType((*LoadBalancerConfigRequest)(nil), "moc.lbagent.LoadBalancerConfigRequest")
	proto.RegisterType((*LoadBalancerConfigResponse)(nil), "moc.lbagent.LoadBalancerConfigResponse")
	proto.RegisterType((*LoadBalancerPeerRequest)(nil), "moc.lbagent.LoadBalancerPeerRequest")
	proto.RegisterType((*LoadBalancerPeerResponse)(nil), "moc.lbagent.LoadBalancerPeerResponse")
	proto.RegisterType((*LoadBalancerResyncRequest)(nil), "moc.lbagent.LoadBalancerResyncRequest")
	proto.RegisterType((*LoadBalancerResyncResponse)(nil), "moc.lbagent.LoadBalancerResyncResponse")
}

func init() { proto.RegisterFile("moc_lbagent_agent.proto", fileDescriptor_f2129e850e085f66) }

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

// 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.SupportPackageIsVersion4

// LoadBalancerAgentClient is the client API for LoadBalancerAgent service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LoadBalancerAgentClient interface {
	Create(ctx context.Context, in *LoadBalancerRequest, opts ...grpc.CallOption) (*LoadBalancerResponse, error)
	Delete(ctx context.Context, in *LoadBalancerRequest, opts ...grpc.CallOption) (*LoadBalancerResponse, error)
	Get(ctx context.Context, in *LoadBalancerRequest, opts ...grpc.CallOption) (*LoadBalancerResponse, error)
	//GetConfig is for debugging/testing
	GetConfig(ctx context.Context, in *LoadBalancerConfigRequest, opts ...grpc.CallOption) (*LoadBalancerConfigResponse, error)
	CheckNotification(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*common.NotificationResponse, error)
	AddPeer(ctx context.Context, in *LoadBalancerPeerRequest, opts ...grpc.CallOption) (*LoadBalancerPeerResponse, error)
	RemovePeer(ctx context.Context, in *LoadBalancerPeerRequest, opts ...grpc.CallOption) (*LoadBalancerPeerResponse, error)
	Resync(ctx context.Context, in *LoadBalancerResyncRequest, opts ...grpc.CallOption) (*LoadBalancerResyncResponse, error)
}

type loadBalancerAgentClient struct {
	cc *grpc.ClientConn
}

func NewLoadBalancerAgentClient(cc *grpc.ClientConn) LoadBalancerAgentClient {
	return &loadBalancerAgentClient{cc}
}

func (c *loadBalancerAgentClient) Create(ctx context.Context, in *LoadBalancerRequest, opts ...grpc.CallOption) (*LoadBalancerResponse, error) {
	out := new(LoadBalancerResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loadBalancerAgentClient) Delete(ctx context.Context, in *LoadBalancerRequest, opts ...grpc.CallOption) (*LoadBalancerResponse, error) {
	out := new(LoadBalancerResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loadBalancerAgentClient) Get(ctx context.Context, in *LoadBalancerRequest, opts ...grpc.CallOption) (*LoadBalancerResponse, error) {
	out := new(LoadBalancerResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loadBalancerAgentClient) GetConfig(ctx context.Context, in *LoadBalancerConfigRequest, opts ...grpc.CallOption) (*LoadBalancerConfigResponse, error) {
	out := new(LoadBalancerConfigResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/GetConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loadBalancerAgentClient) CheckNotification(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*common.NotificationResponse, error) {
	out := new(common.NotificationResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/CheckNotification", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loadBalancerAgentClient) AddPeer(ctx context.Context, in *LoadBalancerPeerRequest, opts ...grpc.CallOption) (*LoadBalancerPeerResponse, error) {
	out := new(LoadBalancerPeerResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/AddPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loadBalancerAgentClient) RemovePeer(ctx context.Context, in *LoadBalancerPeerRequest, opts ...grpc.CallOption) (*LoadBalancerPeerResponse, error) {
	out := new(LoadBalancerPeerResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/RemovePeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *loadBalancerAgentClient) Resync(ctx context.Context, in *LoadBalancerResyncRequest, opts ...grpc.CallOption) (*LoadBalancerResyncResponse, error) {
	out := new(LoadBalancerResyncResponse)
	err := c.cc.Invoke(ctx, "/moc.lbagent.LoadBalancerAgent/Resync", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LoadBalancerAgentServer is the server API for LoadBalancerAgent service.
type LoadBalancerAgentServer interface {
	Create(context.Context, *LoadBalancerRequest) (*LoadBalancerResponse, error)
	Delete(context.Context, *LoadBalancerRequest) (*LoadBalancerResponse, error)
	Get(context.Context, *LoadBalancerRequest) (*LoadBalancerResponse, error)
	//GetConfig is for debugging/testing
	GetConfig(context.Context, *LoadBalancerConfigRequest) (*LoadBalancerConfigResponse, error)
	CheckNotification(context.Context, *empty.Empty) (*common.NotificationResponse, error)
	AddPeer(context.Context, *LoadBalancerPeerRequest) (*LoadBalancerPeerResponse, error)
	RemovePeer(context.Context, *LoadBalancerPeerRequest) (*LoadBalancerPeerResponse, error)
	Resync(context.Context, *LoadBalancerResyncRequest) (*LoadBalancerResyncResponse, error)
}

// UnimplementedLoadBalancerAgentServer can be embedded to have forward compatible implementations.
type UnimplementedLoadBalancerAgentServer struct {
}

func (*UnimplementedLoadBalancerAgentServer) Create(ctx context.Context, req *LoadBalancerRequest) (*LoadBalancerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (*UnimplementedLoadBalancerAgentServer) Delete(ctx context.Context, req *LoadBalancerRequest) (*LoadBalancerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (*UnimplementedLoadBalancerAgentServer) Get(ctx context.Context, req *LoadBalancerRequest) (*LoadBalancerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedLoadBalancerAgentServer) GetConfig(ctx context.Context, req *LoadBalancerConfigRequest) (*LoadBalancerConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConfig not implemented")
}
func (*UnimplementedLoadBalancerAgentServer) CheckNotification(ctx context.Context, req *empty.Empty) (*common.NotificationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckNotification not implemented")
}
func (*UnimplementedLoadBalancerAgentServer) AddPeer(ctx context.Context, req *LoadBalancerPeerRequest) (*LoadBalancerPeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPeer not implemented")
}
func (*UnimplementedLoadBalancerAgentServer) RemovePeer(ctx context.Context, req *LoadBalancerPeerRequest) (*LoadBalancerPeerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemovePeer not implemented")
}
func (*UnimplementedLoadBalancerAgentServer) Resync(ctx context.Context, req *LoadBalancerResyncRequest) (*LoadBalancerResyncResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Resync not implemented")
}

func RegisterLoadBalancerAgentServer(s *grpc.Server, srv LoadBalancerAgentServer) {
	s.RegisterService(&_LoadBalancerAgent_serviceDesc, srv)
}

func _LoadBalancerAgent_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBalancerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).Create(ctx, req.(*LoadBalancerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LoadBalancerAgent_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBalancerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).Delete(ctx, req.(*LoadBalancerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LoadBalancerAgent_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBalancerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).Get(ctx, req.(*LoadBalancerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LoadBalancerAgent_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBalancerConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).GetConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/GetConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).GetConfig(ctx, req.(*LoadBalancerConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LoadBalancerAgent_CheckNotification_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).CheckNotification(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/CheckNotification",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).CheckNotification(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _LoadBalancerAgent_AddPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBalancerPeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).AddPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/AddPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).AddPeer(ctx, req.(*LoadBalancerPeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LoadBalancerAgent_RemovePeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBalancerPeerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).RemovePeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/RemovePeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).RemovePeer(ctx, req.(*LoadBalancerPeerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LoadBalancerAgent_Resync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBalancerResyncRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LoadBalancerAgentServer).Resync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/moc.lbagent.LoadBalancerAgent/Resync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LoadBalancerAgentServer).Resync(ctx, req.(*LoadBalancerResyncRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _LoadBalancerAgent_serviceDesc = grpc.ServiceDesc{
	ServiceName: "moc.lbagent.LoadBalancerAgent",
	HandlerType: (*LoadBalancerAgentServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _LoadBalancerAgent_Create_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _LoadBalancerAgent_Delete_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _LoadBalancerAgent_Get_Handler,
		},
		{
			MethodName: "GetConfig",
			Handler:    _LoadBalancerAgent_GetConfig_Handler,
		},
		{
			MethodName: "CheckNotification",
			Handler:    _LoadBalancerAgent_CheckNotification_Handler,
		},
		{
			MethodName: "AddPeer",
			Handler:    _LoadBalancerAgent_AddPeer_Handler,
		},
		{
			MethodName: "RemovePeer",
			Handler:    _LoadBalancerAgent_RemovePeer_Handler,
		},
		{
			MethodName: "Resync",
			Handler:    _LoadBalancerAgent_Resync_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "moc_lbagent_agent.proto",
}