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

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