vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/messages/messages.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: grpc_lb_v1/messages/messages.proto
   3
   4 /*
   5 Package messages is a generated protocol buffer package.
   6
   7 It is generated from these files:
   8         grpc_lb_v1/messages/messages.proto
   9
  10 It has these top-level messages:
  11         Duration
  12         Timestamp
  13         LoadBalanceRequest
  14         InitialLoadBalanceRequest
  15         ClientStats
  16         LoadBalanceResponse
  17         InitialLoadBalanceResponse
  18         ServerList
  19         Server
  20 */
  21 package messages
  22
  23 import proto "github.com/golang/protobuf/proto"
  24 import fmt "fmt"
  25 import math "math"
  26
  27 // Reference imports to suppress errors if they are not otherwise used.
  28 var _ = proto.Marshal
  29 var _ = fmt.Errorf
  30 var _ = math.Inf
  31
  32 // This is a compile-time assertion to ensure that this generated file
  33 // is compatible with the proto package it is being compiled against.
  34 // A compilation error at this line likely means your copy of the
  35 // proto package needs to be updated.
  36 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  37
  38 type Duration struct {
  39         // Signed seconds of the span of time. Must be from -315,576,000,000
  40         // to +315,576,000,000 inclusive.
  41         Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
  42         // Signed fractions of a second at nanosecond resolution of the span
  43         // of time. Durations less than one second are represented with a 0
  44         // `seconds` field and a positive or negative `nanos` field. For durations
  45         // of one second or more, a non-zero value for the `nanos` field must be
  46         // of the same sign as the `seconds` field. Must be from -999,999,999
  47         // to +999,999,999 inclusive.
  48         Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
  49 }
  50
  51 func (m *Duration) Reset()                    { *m = Duration{} }
  52 func (m *Duration) String() string            { return proto.CompactTextString(m) }
  53 func (*Duration) ProtoMessage()               {}
  54 func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
  55
  56 func (m *Duration) GetSeconds() int64 {
  57         if m != nil {
  58                 return m.Seconds
  59         }
  60         return 0
  61 }
  62
  63 func (m *Duration) GetNanos() int32 {
  64         if m != nil {
  65                 return m.Nanos
  66         }
  67         return 0
  68 }
  69
  70 type Timestamp struct {
  71         // Represents seconds of UTC time since Unix epoch
  72         // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
  73         // 9999-12-31T23:59:59Z inclusive.
  74         Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
  75         // Non-negative fractions of a second at nanosecond resolution. Negative
  76         // second values with fractions must still have non-negative nanos values
  77         // that count forward in time. Must be from 0 to 999,999,999
  78         // inclusive.
  79         Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
  80 }
  81
  82 func (m *Timestamp) Reset()                    { *m = Timestamp{} }
  83 func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
  84 func (*Timestamp) ProtoMessage()               {}
  85 func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
  86
  87 func (m *Timestamp) GetSeconds() int64 {
  88         if m != nil {
  89                 return m.Seconds
  90         }
  91         return 0
  92 }
  93
  94 func (m *Timestamp) GetNanos() int32 {
  95         if m != nil {
  96                 return m.Nanos
  97         }
  98         return 0
  99 }
 100
 101 type LoadBalanceRequest struct {
 102         // Types that are valid to be assigned to LoadBalanceRequestType:
 103         //      *LoadBalanceRequest_InitialRequest
 104         //      *LoadBalanceRequest_ClientStats
 105         LoadBalanceRequestType isLoadBalanceRequest_LoadBalanceRequestType `protobuf_oneof:"load_balance_request_type"`
 106 }
 107
 108 func (m *LoadBalanceRequest) Reset()                    { *m = LoadBalanceRequest{} }
 109 func (m *LoadBalanceRequest) String() string            { return proto.CompactTextString(m) }
 110 func (*LoadBalanceRequest) ProtoMessage()               {}
 111 func (*LoadBalanceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 112
 113 type isLoadBalanceRequest_LoadBalanceRequestType interface {
 114         isLoadBalanceRequest_LoadBalanceRequestType()
 115 }
 116
 117 type LoadBalanceRequest_InitialRequest struct {
 118         InitialRequest *InitialLoadBalanceRequest `protobuf:"bytes,1,opt,name=initial_request,json=initialRequest,oneof"`
 119 }
 120 type LoadBalanceRequest_ClientStats struct {
 121         ClientStats *ClientStats `protobuf:"bytes,2,opt,name=client_stats,json=clientStats,oneof"`
 122 }
 123
 124 func (*LoadBalanceRequest_InitialRequest) isLoadBalanceRequest_LoadBalanceRequestType() {}
 125 func (*LoadBalanceRequest_ClientStats) isLoadBalanceRequest_LoadBalanceRequestType()    {}
 126
 127 func (m *LoadBalanceRequest) GetLoadBalanceRequestType() isLoadBalanceRequest_LoadBalanceRequestType {
 128         if m != nil {
 129                 return m.LoadBalanceRequestType
 130         }
 131         return nil
 132 }
 133
 134 func (m *LoadBalanceRequest) GetInitialRequest() *InitialLoadBalanceRequest {
 135         if x, ok := m.GetLoadBalanceRequestType().(*LoadBalanceRequest_InitialRequest); ok {
 136                 return x.InitialRequest
 137         }
 138         return nil
 139 }
 140
 141 func (m *LoadBalanceRequest) GetClientStats() *ClientStats {
 142         if x, ok := m.GetLoadBalanceRequestType().(*LoadBalanceRequest_ClientStats); ok {
 143                 return x.ClientStats
 144         }
 145         return nil
 146 }
 147
 148 // XXX_OneofFuncs is for the internal use of the proto package.
 149 func (*LoadBalanceRequest) 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{}) {
 150         return _LoadBalanceRequest_OneofMarshaler, _LoadBalanceRequest_OneofUnmarshaler, _LoadBalanceRequest_OneofSizer, []interface{}{
 151                 (*LoadBalanceRequest_InitialRequest)(nil),
 152                 (*LoadBalanceRequest_ClientStats)(nil),
 153         }
 154 }
 155
 156 func _LoadBalanceRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 157         m := msg.(*LoadBalanceRequest)
 158         // load_balance_request_type
 159         switch x := m.LoadBalanceRequestType.(type) {
 160         case *LoadBalanceRequest_InitialRequest:
 161                 b.EncodeVarint(1<<3 | proto.WireBytes)
 162                 if err := b.EncodeMessage(x.InitialRequest); err != nil {
 163                         return err
 164                 }
 165         case *LoadBalanceRequest_ClientStats:
 166                 b.EncodeVarint(2<<3 | proto.WireBytes)
 167                 if err := b.EncodeMessage(x.ClientStats); err != nil {
 168                         return err
 169                 }
 170         case nil:
 171         default:
 172                 return fmt.Errorf("LoadBalanceRequest.LoadBalanceRequestType has unexpected type %T", x)
 173         }
 174         return nil
 175 }
 176
 177 func _LoadBalanceRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 178         m := msg.(*LoadBalanceRequest)
 179         switch tag {
 180         case 1: // load_balance_request_type.initial_request
 181                 if wire != proto.WireBytes {
 182                         return true, proto.ErrInternalBadWireType
 183                 }
 184                 msg := new(InitialLoadBalanceRequest)
 185                 err := b.DecodeMessage(msg)
 186                 m.LoadBalanceRequestType = &LoadBalanceRequest_InitialRequest{msg}
 187                 return true, err
 188         case 2: // load_balance_request_type.client_stats
 189                 if wire != proto.WireBytes {
 190                         return true, proto.ErrInternalBadWireType
 191                 }
 192                 msg := new(ClientStats)
 193                 err := b.DecodeMessage(msg)
 194                 m.LoadBalanceRequestType = &LoadBalanceRequest_ClientStats{msg}
 195                 return true, err
 196         default:
 197                 return false, nil
 198         }
 199 }
 200
 201 func _LoadBalanceRequest_OneofSizer(msg proto.Message) (n int) {
 202         m := msg.(*LoadBalanceRequest)
 203         // load_balance_request_type
 204         switch x := m.LoadBalanceRequestType.(type) {
 205         case *LoadBalanceRequest_InitialRequest:
 206                 s := proto.Size(x.InitialRequest)
 207                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 208                 n += proto.SizeVarint(uint64(s))
 209                 n += s
 210         case *LoadBalanceRequest_ClientStats:
 211                 s := proto.Size(x.ClientStats)
 212                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 213                 n += proto.SizeVarint(uint64(s))
 214                 n += s
 215         case nil:
 216         default:
 217                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 218         }
 219         return n
 220 }
 221
 222 type InitialLoadBalanceRequest struct {
 223         // Name of load balanced service (IE, balancer.service.com)
 224         // length should be less than 256 bytes.
 225         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
 226 }
 227
 228 func (m *InitialLoadBalanceRequest) Reset()                    { *m = InitialLoadBalanceRequest{} }
 229 func (m *InitialLoadBalanceRequest) String() string            { return proto.CompactTextString(m) }
 230 func (*InitialLoadBalanceRequest) ProtoMessage()               {}
 231 func (*InitialLoadBalanceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 232
 233 func (m *InitialLoadBalanceRequest) GetName() string {
 234         if m != nil {
 235                 return m.Name
 236         }
 237         return ""
 238 }
 239
 240 // Contains client level statistics that are useful to load balancing. Each
 241 // count except the timestamp should be reset to zero after reporting the stats.
 242 type ClientStats struct {
 243         // The timestamp of generating the report.
 244         Timestamp *Timestamp `protobuf:"bytes,1,opt,name=timestamp" json:"timestamp,omitempty"`
 245         // The total number of RPCs that started.
 246         NumCallsStarted int64 `protobuf:"varint,2,opt,name=num_calls_started,json=numCallsStarted" json:"num_calls_started,omitempty"`
 247         // The total number of RPCs that finished.
 248         NumCallsFinished int64 `protobuf:"varint,3,opt,name=num_calls_finished,json=numCallsFinished" json:"num_calls_finished,omitempty"`
 249         // The total number of RPCs that were dropped by the client because of rate
 250         // limiting.
 251         NumCallsFinishedWithDropForRateLimiting int64 `protobuf:"varint,4,opt,name=num_calls_finished_with_drop_for_rate_limiting,json=numCallsFinishedWithDropForRateLimiting" json:"num_calls_finished_with_drop_for_rate_limiting,omitempty"`
 252         // The total number of RPCs that were dropped by the client because of load
 253         // balancing.
 254         NumCallsFinishedWithDropForLoadBalancing int64 `protobuf:"varint,5,opt,name=num_calls_finished_with_drop_for_load_balancing,json=numCallsFinishedWithDropForLoadBalancing" json:"num_calls_finished_with_drop_for_load_balancing,omitempty"`
 255         // The total number of RPCs that failed to reach a server except dropped RPCs.
 256         NumCallsFinishedWithClientFailedToSend int64 `protobuf:"varint,6,opt,name=num_calls_finished_with_client_failed_to_send,json=numCallsFinishedWithClientFailedToSend" json:"num_calls_finished_with_client_failed_to_send,omitempty"`
 257         // The total number of RPCs that finished and are known to have been received
 258         // by a server.
 259         NumCallsFinishedKnownReceived int64 `protobuf:"varint,7,opt,name=num_calls_finished_known_received,json=numCallsFinishedKnownReceived" json:"num_calls_finished_known_received,omitempty"`
 260 }
 261
 262 func (m *ClientStats) Reset()                    { *m = ClientStats{} }
 263 func (m *ClientStats) String() string            { return proto.CompactTextString(m) }
 264 func (*ClientStats) ProtoMessage()               {}
 265 func (*ClientStats) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 266
 267 func (m *ClientStats) GetTimestamp() *Timestamp {
 268         if m != nil {
 269                 return m.Timestamp
 270         }
 271         return nil
 272 }
 273
 274 func (m *ClientStats) GetNumCallsStarted() int64 {
 275         if m != nil {
 276                 return m.NumCallsStarted
 277         }
 278         return 0
 279 }
 280
 281 func (m *ClientStats) GetNumCallsFinished() int64 {
 282         if m != nil {
 283                 return m.NumCallsFinished
 284         }
 285         return 0
 286 }
 287
 288 func (m *ClientStats) GetNumCallsFinishedWithDropForRateLimiting() int64 {
 289         if m != nil {
 290                 return m.NumCallsFinishedWithDropForRateLimiting
 291         }
 292         return 0
 293 }
 294
 295 func (m *ClientStats) GetNumCallsFinishedWithDropForLoadBalancing() int64 {
 296         if m != nil {
 297                 return m.NumCallsFinishedWithDropForLoadBalancing
 298         }
 299         return 0
 300 }
 301
 302 func (m *ClientStats) GetNumCallsFinishedWithClientFailedToSend() int64 {
 303         if m != nil {
 304                 return m.NumCallsFinishedWithClientFailedToSend
 305         }
 306         return 0
 307 }
 308
 309 func (m *ClientStats) GetNumCallsFinishedKnownReceived() int64 {
 310         if m != nil {
 311                 return m.NumCallsFinishedKnownReceived
 312         }
 313         return 0
 314 }
 315
 316 type LoadBalanceResponse struct {
 317         // Types that are valid to be assigned to LoadBalanceResponseType:
 318         //      *LoadBalanceResponse_InitialResponse
 319         //      *LoadBalanceResponse_ServerList
 320         LoadBalanceResponseType isLoadBalanceResponse_LoadBalanceResponseType `protobuf_oneof:"load_balance_response_type"`
 321 }
 322
 323 func (m *LoadBalanceResponse) Reset()                    { *m = LoadBalanceResponse{} }
 324 func (m *LoadBalanceResponse) String() string            { return proto.CompactTextString(m) }
 325 func (*LoadBalanceResponse) ProtoMessage()               {}
 326 func (*LoadBalanceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 327
 328 type isLoadBalanceResponse_LoadBalanceResponseType interface {
 329         isLoadBalanceResponse_LoadBalanceResponseType()
 330 }
 331
 332 type LoadBalanceResponse_InitialResponse struct {
 333         InitialResponse *InitialLoadBalanceResponse `protobuf:"bytes,1,opt,name=initial_response,json=initialResponse,oneof"`
 334 }
 335 type LoadBalanceResponse_ServerList struct {
 336         ServerList *ServerList `protobuf:"bytes,2,opt,name=server_list,json=serverList,oneof"`
 337 }
 338
 339 func (*LoadBalanceResponse_InitialResponse) isLoadBalanceResponse_LoadBalanceResponseType() {}
 340 func (*LoadBalanceResponse_ServerList) isLoadBalanceResponse_LoadBalanceResponseType()      {}
 341
 342 func (m *LoadBalanceResponse) GetLoadBalanceResponseType() isLoadBalanceResponse_LoadBalanceResponseType {
 343         if m != nil {
 344                 return m.LoadBalanceResponseType
 345         }
 346         return nil
 347 }
 348
 349 func (m *LoadBalanceResponse) GetInitialResponse() *InitialLoadBalanceResponse {
 350         if x, ok := m.GetLoadBalanceResponseType().(*LoadBalanceResponse_InitialResponse); ok {
 351                 return x.InitialResponse
 352         }
 353         return nil
 354 }
 355
 356 func (m *LoadBalanceResponse) GetServerList() *ServerList {
 357         if x, ok := m.GetLoadBalanceResponseType().(*LoadBalanceResponse_ServerList); ok {
 358                 return x.ServerList
 359         }
 360         return nil
 361 }
 362
 363 // XXX_OneofFuncs is for the internal use of the proto package.
 364 func (*LoadBalanceResponse) 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{}) {
 365         return _LoadBalanceResponse_OneofMarshaler, _LoadBalanceResponse_OneofUnmarshaler, _LoadBalanceResponse_OneofSizer, []interface{}{
 366                 (*LoadBalanceResponse_InitialResponse)(nil),
 367                 (*LoadBalanceResponse_ServerList)(nil),
 368         }
 369 }
 370
 371 func _LoadBalanceResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 372         m := msg.(*LoadBalanceResponse)
 373         // load_balance_response_type
 374         switch x := m.LoadBalanceResponseType.(type) {
 375         case *LoadBalanceResponse_InitialResponse:
 376                 b.EncodeVarint(1<<3 | proto.WireBytes)
 377                 if err := b.EncodeMessage(x.InitialResponse); err != nil {
 378                         return err
 379                 }
 380         case *LoadBalanceResponse_ServerList:
 381                 b.EncodeVarint(2<<3 | proto.WireBytes)
 382                 if err := b.EncodeMessage(x.ServerList); err != nil {
 383                         return err
 384                 }
 385         case nil:
 386         default:
 387                 return fmt.Errorf("LoadBalanceResponse.LoadBalanceResponseType has unexpected type %T", x)
 388         }
 389         return nil
 390 }
 391
 392 func _LoadBalanceResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 393         m := msg.(*LoadBalanceResponse)
 394         switch tag {
 395         case 1: // load_balance_response_type.initial_response
 396                 if wire != proto.WireBytes {
 397                         return true, proto.ErrInternalBadWireType
 398                 }
 399                 msg := new(InitialLoadBalanceResponse)
 400                 err := b.DecodeMessage(msg)
 401                 m.LoadBalanceResponseType = &LoadBalanceResponse_InitialResponse{msg}
 402                 return true, err
 403         case 2: // load_balance_response_type.server_list
 404                 if wire != proto.WireBytes {
 405                         return true, proto.ErrInternalBadWireType
 406                 }
 407                 msg := new(ServerList)
 408                 err := b.DecodeMessage(msg)
 409                 m.LoadBalanceResponseType = &LoadBalanceResponse_ServerList{msg}
 410                 return true, err
 411         default:
 412                 return false, nil
 413         }
 414 }
 415
 416 func _LoadBalanceResponse_OneofSizer(msg proto.Message) (n int) {
 417         m := msg.(*LoadBalanceResponse)
 418         // load_balance_response_type
 419         switch x := m.LoadBalanceResponseType.(type) {
 420         case *LoadBalanceResponse_InitialResponse:
 421                 s := proto.Size(x.InitialResponse)
 422                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 423                 n += proto.SizeVarint(uint64(s))
 424                 n += s
 425         case *LoadBalanceResponse_ServerList:
 426                 s := proto.Size(x.ServerList)
 427                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 428                 n += proto.SizeVarint(uint64(s))
 429                 n += s
 430         case nil:
 431         default:
 432                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 433         }
 434         return n
 435 }
 436
 437 type InitialLoadBalanceResponse struct {
 438         // This is an application layer redirect that indicates the client should use
 439         // the specified server for load balancing. When this field is non-empty in
 440         // the response, the client should open a separate connection to the
 441         // load_balancer_delegate and call the BalanceLoad method. Its length should
 442         // be less than 64 bytes.
 443         LoadBalancerDelegate string `protobuf:"bytes,1,opt,name=load_balancer_delegate,json=loadBalancerDelegate" json:"load_balancer_delegate,omitempty"`
 444         // This interval defines how often the client should send the client stats
 445         // to the load balancer. Stats should only be reported when the duration is
 446         // positive.
 447         ClientStatsReportInterval *Duration `protobuf:"bytes,2,opt,name=client_stats_report_interval,json=clientStatsReportInterval" json:"client_stats_report_interval,omitempty"`
 448 }
 449
 450 func (m *InitialLoadBalanceResponse) Reset()                    { *m = InitialLoadBalanceResponse{} }
 451 func (m *InitialLoadBalanceResponse) String() string            { return proto.CompactTextString(m) }
 452 func (*InitialLoadBalanceResponse) ProtoMessage()               {}
 453 func (*InitialLoadBalanceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 454
 455 func (m *InitialLoadBalanceResponse) GetLoadBalancerDelegate() string {
 456         if m != nil {
 457                 return m.LoadBalancerDelegate
 458         }
 459         return ""
 460 }
 461
 462 func (m *InitialLoadBalanceResponse) GetClientStatsReportInterval() *Duration {
 463         if m != nil {
 464                 return m.ClientStatsReportInterval
 465         }
 466         return nil
 467 }
 468
 469 type ServerList struct {
 470         // Contains a list of servers selected by the load balancer. The list will
 471         // be updated when server resolutions change or as needed to balance load
 472         // across more servers. The client should consume the server list in order
 473         // unless instructed otherwise via the client_config.
 474         Servers []*Server `protobuf:"bytes,1,rep,name=servers" json:"servers,omitempty"`
 475 }
 476
 477 func (m *ServerList) Reset()                    { *m = ServerList{} }
 478 func (m *ServerList) String() string            { return proto.CompactTextString(m) }
 479 func (*ServerList) ProtoMessage()               {}
 480 func (*ServerList) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 481
 482 func (m *ServerList) GetServers() []*Server {
 483         if m != nil {
 484                 return m.Servers
 485         }
 486         return nil
 487 }
 488
 489 // Contains server information. When none of the [drop_for_*] fields are true,
 490 // use the other fields. When drop_for_rate_limiting is true, ignore all other
 491 // fields. Use drop_for_load_balancing only when it is true and
 492 // drop_for_rate_limiting is false.
 493 type Server struct {
 494         // A resolved address for the server, serialized in network-byte-order. It may
 495         // either be an IPv4 or IPv6 address.
 496         IpAddress []byte `protobuf:"bytes,1,opt,name=ip_address,json=ipAddress,proto3" json:"ip_address,omitempty"`
 497         // A resolved port number for the server.
 498         Port int32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
 499         // An opaque but printable token given to the frontend for each pick. All
 500         // frontend requests for that pick must include the token in its initial
 501         // metadata. The token is used by the backend to verify the request and to
 502         // allow the backend to report load to the gRPC LB system.
 503         //
 504         // Its length is variable but less than 50 bytes.
 505         LoadBalanceToken string `protobuf:"bytes,3,opt,name=load_balance_token,json=loadBalanceToken" json:"load_balance_token,omitempty"`
 506         // Indicates whether this particular request should be dropped by the client
 507         // for rate limiting.
 508         DropForRateLimiting bool `protobuf:"varint,4,opt,name=drop_for_rate_limiting,json=dropForRateLimiting" json:"drop_for_rate_limiting,omitempty"`
 509         // Indicates whether this particular request should be dropped by the client
 510         // for load balancing.
 511         DropForLoadBalancing bool `protobuf:"varint,5,opt,name=drop_for_load_balancing,json=dropForLoadBalancing" json:"drop_for_load_balancing,omitempty"`
 512 }
 513
 514 func (m *Server) Reset()                    { *m = Server{} }
 515 func (m *Server) String() string            { return proto.CompactTextString(m) }
 516 func (*Server) ProtoMessage()               {}
 517 func (*Server) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 518
 519 func (m *Server) GetIpAddress() []byte {
 520         if m != nil {
 521                 return m.IpAddress
 522         }
 523         return nil
 524 }
 525
 526 func (m *Server) GetPort() int32 {
 527         if m != nil {
 528                 return m.Port
 529         }
 530         return 0
 531 }
 532
 533 func (m *Server) GetLoadBalanceToken() string {
 534         if m != nil {
 535                 return m.LoadBalanceToken
 536         }
 537         return ""
 538 }
 539
 540 func (m *Server) GetDropForRateLimiting() bool {
 541         if m != nil {
 542                 return m.DropForRateLimiting
 543         }
 544         return false
 545 }
 546
 547 func (m *Server) GetDropForLoadBalancing() bool {
 548         if m != nil {
 549                 return m.DropForLoadBalancing
 550         }
 551         return false
 552 }
 553
 554 func init() {
 555         proto.RegisterType((*Duration)(nil), "grpc.lb.v1.Duration")
 556         proto.RegisterType((*Timestamp)(nil), "grpc.lb.v1.Timestamp")
 557         proto.RegisterType((*LoadBalanceRequest)(nil), "grpc.lb.v1.LoadBalanceRequest")
 558         proto.RegisterType((*InitialLoadBalanceRequest)(nil), "grpc.lb.v1.InitialLoadBalanceRequest")
 559         proto.RegisterType((*ClientStats)(nil), "grpc.lb.v1.ClientStats")
 560         proto.RegisterType((*LoadBalanceResponse)(nil), "grpc.lb.v1.LoadBalanceResponse")
 561         proto.RegisterType((*InitialLoadBalanceResponse)(nil), "grpc.lb.v1.InitialLoadBalanceResponse")
 562         proto.RegisterType((*ServerList)(nil), "grpc.lb.v1.ServerList")
 563         proto.RegisterType((*Server)(nil), "grpc.lb.v1.Server")
 564 }
 565
 566 func init() { proto.RegisterFile("grpc_lb_v1/messages/messages.proto", fileDescriptor0) }
 567
 568 var fileDescriptor0 = []byte{
 569         // 709 bytes of a gzipped FileDescriptorProto
 570         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xdd, 0x4e, 0x1b, 0x3b,
 571         0x10, 0x26, 0x27, 0x01, 0x92, 0x09, 0x3a, 0xe4, 0x98, 0x1c, 0x08, 0x14, 0x24, 0xba, 0x52, 0x69,
 572         0x54, 0xd1, 0x20, 0xa0, 0xbd, 0xe8, 0xcf, 0x45, 0x1b, 0x10, 0x0a, 0x2d, 0x17, 0x95, 0x43, 0x55,
 573         0xa9, 0x52, 0x65, 0x39, 0xd9, 0x21, 0x58, 0x6c, 0xec, 0xad, 0xed, 0x04, 0xf5, 0x11, 0xfa, 0x28,
 574         0x7d, 0x8c, 0xaa, 0xcf, 0xd0, 0xf7, 0xa9, 0xd6, 0xbb, 0x9b, 0x5d, 0x20, 0x80, 0x7a, 0x67, 0x8f,
 575         0xbf, 0xf9, 0xbe, 0xf1, 0xac, 0xbf, 0x59, 0xf0, 0x06, 0x3a, 0xec, 0xb3, 0xa0, 0xc7, 0xc6, 0xbb,
 576         0x3b, 0x43, 0x34, 0x86, 0x0f, 0xd0, 0x4c, 0x16, 0xad, 0x50, 0x2b, 0xab, 0x08, 0x44, 0x98, 0x56,
 577         0xd0, 0x6b, 0x8d, 0x77, 0xbd, 0x97, 0x50, 0x3e, 0x1c, 0x69, 0x6e, 0x85, 0x92, 0xa4, 0x01, 0xf3,
 578         0x06, 0xfb, 0x4a, 0xfa, 0xa6, 0x51, 0xd8, 0x2c, 0x34, 0x8b, 0x34, 0xdd, 0x92, 0x3a, 0xcc, 0x4a,
 579         0x2e, 0x95, 0x69, 0xfc, 0xb3, 0x59, 0x68, 0xce, 0xd2, 0x78, 0xe3, 0xbd, 0x82, 0xca, 0xa9, 0x18,
 580         0xa2, 0xb1, 0x7c, 0x18, 0xfe, 0x75, 0xf2, 0xcf, 0x02, 0x90, 0x13, 0xc5, 0xfd, 0x36, 0x0f, 0xb8,
 581         0xec, 0x23, 0xc5, 0xaf, 0x23, 0x34, 0x96, 0x7c, 0x80, 0x45, 0x21, 0x85, 0x15, 0x3c, 0x60, 0x3a,
 582         0x0e, 0x39, 0xba, 0xea, 0xde, 0xa3, 0x56, 0x56, 0x75, 0xeb, 0x38, 0x86, 0xdc, 0xcc, 0xef, 0xcc,
 583         0xd0, 0x7f, 0x93, 0xfc, 0x94, 0xf1, 0x35, 0x2c, 0xf4, 0x03, 0x81, 0xd2, 0x32, 0x63, 0xb9, 0x8d,
 584         0xab, 0xa8, 0xee, 0xad, 0xe4, 0xe9, 0x0e, 0xdc, 0x79, 0x37, 0x3a, 0xee, 0xcc, 0xd0, 0x6a, 0x3f,
 585         0xdb, 0xb6, 0x1f, 0xc0, 0x6a, 0xa0, 0xb8, 0xcf, 0x7a, 0xb1, 0x4c, 0x5a, 0x14, 0xb3, 0xdf, 0x42,
 586         0xf4, 0x76, 0x60, 0xf5, 0xd6, 0x4a, 0x08, 0x81, 0x92, 0xe4, 0x43, 0x74, 0xe5, 0x57, 0xa8, 0x5b,
 587         0x7b, 0xdf, 0x4b, 0x50, 0xcd, 0x89, 0x91, 0x7d, 0xa8, 0xd8, 0xb4, 0x83, 0xc9, 0x3d, 0xff, 0xcf,
 588         0x17, 0x36, 0x69, 0x2f, 0xcd, 0x70, 0xe4, 0x09, 0xfc, 0x27, 0x47, 0x43, 0xd6, 0xe7, 0x41, 0x60,
 589         0xa2, 0x3b, 0x69, 0x8b, 0xbe, 0xbb, 0x55, 0x91, 0x2e, 0xca, 0xd1, 0xf0, 0x20, 0x8a, 0x77, 0xe3,
 590         0x30, 0xd9, 0x06, 0x92, 0x61, 0xcf, 0x84, 0x14, 0xe6, 0x1c, 0xfd, 0x46, 0xd1, 0x81, 0x6b, 0x29,
 591         0xf8, 0x28, 0x89, 0x13, 0x06, 0xad, 0x9b, 0x68, 0x76, 0x29, 0xec, 0x39, 0xf3, 0xb5, 0x0a, 0xd9,
 592         0x99, 0xd2, 0x4c, 0x73, 0x8b, 0x2c, 0x10, 0x43, 0x61, 0x85, 0x1c, 0x34, 0x4a, 0x8e, 0xe9, 0xf1,
 593         0x75, 0xa6, 0x4f, 0xc2, 0x9e, 0x1f, 0x6a, 0x15, 0x1e, 0x29, 0x4d, 0xb9, 0xc5, 0x93, 0x04, 0x4e,
 594         0x38, 0xec, 0xdc, 0x2b, 0x90, 0x6b, 0x77, 0xa4, 0x30, 0xeb, 0x14, 0x9a, 0x77, 0x28, 0x64, 0xbd,
 595         0x8f, 0x24, 0xbe, 0xc0, 0xd3, 0xdb, 0x24, 0x92, 0x67, 0x70, 0xc6, 0x45, 0x80, 0x3e, 0xb3, 0x8a,
 596         0x19, 0x94, 0x7e, 0x63, 0xce, 0x09, 0x6c, 0x4d, 0x13, 0x88, 0x3f, 0xd5, 0x91, 0xc3, 0x9f, 0xaa,
 597         0x2e, 0x4a, 0x9f, 0x74, 0xe0, 0xe1, 0x14, 0xfa, 0x0b, 0xa9, 0x2e, 0x25, 0xd3, 0xd8, 0x47, 0x31,
 598         0x46, 0xbf, 0x31, 0xef, 0x28, 0x37, 0xae, 0x53, 0xbe, 0x8f, 0x50, 0x34, 0x01, 0x79, 0xbf, 0x0a,
 599         0xb0, 0x74, 0xe5, 0xd9, 0x98, 0x50, 0x49, 0x83, 0xa4, 0x0b, 0xb5, 0xcc, 0x01, 0x71, 0x2c, 0x79,
 600         0x1a, 0x5b, 0xf7, 0x59, 0x20, 0x46, 0x77, 0x66, 0xe8, 0xe2, 0xc4, 0x03, 0x09, 0xe9, 0x0b, 0xa8,
 601         0x1a, 0xd4, 0x63, 0xd4, 0x2c, 0x10, 0xc6, 0x26, 0x1e, 0x58, 0xce, 0xf3, 0x75, 0xdd, 0xf1, 0x89,
 602         0x70, 0x1e, 0x02, 0x33, 0xd9, 0xb5, 0xd7, 0x61, 0xed, 0x9a, 0x03, 0x62, 0xce, 0xd8, 0x02, 0x3f,
 603         0x0a, 0xb0, 0x76, 0x7b, 0x29, 0xe4, 0x19, 0x2c, 0xe7, 0x93, 0x35, 0xf3, 0x31, 0xc0, 0x01, 0xb7,
 604         0xa9, 0x2d, 0xea, 0x41, 0x96, 0xa4, 0x0f, 0x93, 0x33, 0xf2, 0x11, 0xd6, 0xf3, 0x96, 0x65, 0x1a,
 605         0x43, 0xa5, 0x2d, 0x13, 0xd2, 0xa2, 0x1e, 0xf3, 0x20, 0x29, 0xbf, 0x9e, 0x2f, 0x3f, 0x1d, 0x62,
 606         0x74, 0x35, 0xe7, 0x5e, 0xea, 0xf2, 0x8e, 0x93, 0x34, 0xef, 0x0d, 0x40, 0x76, 0x4b, 0xb2, 0x1d,
 607         0x0d, 0xac, 0x68, 0x17, 0x0d, 0xac, 0x62, 0xb3, 0xba, 0x47, 0x6e, 0xb6, 0x83, 0xa6, 0x90, 0x77,
 608         0xa5, 0x72, 0xb1, 0x56, 0xf2, 0x7e, 0x17, 0x60, 0x2e, 0x3e, 0x21, 0x1b, 0x00, 0x22, 0x64, 0xdc,
 609         0xf7, 0x35, 0x9a, 0x78, 0xe4, 0x2d, 0xd0, 0x8a, 0x08, 0xdf, 0xc6, 0x81, 0xc8, 0xfd, 0x91, 0x76,
 610         0x32, 0xf3, 0xdc, 0x3a, 0x32, 0xe3, 0x95, 0x4e, 0x5a, 0x75, 0x81, 0xd2, 0x99, 0xb1, 0x42, 0x6b,
 611         0xb9, 0x46, 0x9c, 0x46, 0x71, 0xb2, 0x0f, 0xcb, 0x77, 0x98, 0xae, 0x4c, 0x97, 0xfc, 0x29, 0x06,
 612         0x7b, 0x0e, 0x2b, 0x77, 0x19, 0xa9, 0x4c, 0xeb, 0xfe, 0x14, 0xd3, 0xb4, 0xe1, 0x73, 0x39, 0xfd,
 613         0x47, 0xf4, 0xe6, 0xdc, 0x4f, 0x62, 0xff, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x36, 0x86,
 614         0xa6, 0x4a, 0x06, 0x00, 0x00,
 615 }