diff options
Diffstat (limited to 'vendor/google.golang.org/grpc/grpclb')
-rw-r--r-- | vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.pb.go | 629 | ||||
-rw-r--r-- | vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.proto | 164 |
2 files changed, 0 insertions, 793 deletions
diff --git a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.pb.go b/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.pb.go deleted file mode 100644 index f63941b..0000000 --- a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.pb.go +++ /dev/null | |||
@@ -1,629 +0,0 @@ | |||
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 | } | ||
diff --git a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.proto b/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.proto deleted file mode 100644 index b13b343..0000000 --- a/vendor/google.golang.org/grpc/grpclb/grpc_lb_v1/grpclb.proto +++ /dev/null | |||
@@ -1,164 +0,0 @@ | |||
1 | // Copyright 2016 gRPC authors. | ||
2 | // | ||
3 | // Licensed under the Apache License, Version 2.0 (the "License"); | ||
4 | // you may not use this file except in compliance with the License. | ||
5 | // You may obtain a copy of the License at | ||
6 | // | ||
7 | // http://www.apache.org/licenses/LICENSE-2.0 | ||
8 | // | ||
9 | // Unless required by applicable law or agreed to in writing, software | ||
10 | // distributed under the License is distributed on an "AS IS" BASIS, | ||
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
12 | // See the License for the specific language governing permissions and | ||
13 | // limitations under the License. | ||
14 | |||
15 | syntax = "proto3"; | ||
16 | |||
17 | package grpc.lb.v1; | ||
18 | |||
19 | message Duration { | ||
20 | // Signed seconds of the span of time. Must be from -315,576,000,000 | ||
21 | // to +315,576,000,000 inclusive. | ||
22 | int64 seconds = 1; | ||
23 | |||
24 | // Signed fractions of a second at nanosecond resolution of the span | ||
25 | // of time. Durations less than one second are represented with a 0 | ||
26 | // `seconds` field and a positive or negative `nanos` field. For durations | ||
27 | // of one second or more, a non-zero value for the `nanos` field must be | ||
28 | // of the same sign as the `seconds` field. Must be from -999,999,999 | ||
29 | // to +999,999,999 inclusive. | ||
30 | int32 nanos = 2; | ||
31 | } | ||
32 | |||
33 | message Timestamp { | ||
34 | |||
35 | // Represents seconds of UTC time since Unix epoch | ||
36 | // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to | ||
37 | // 9999-12-31T23:59:59Z inclusive. | ||
38 | int64 seconds = 1; | ||
39 | |||
40 | // Non-negative fractions of a second at nanosecond resolution. Negative | ||
41 | // second values with fractions must still have non-negative nanos values | ||
42 | // that count forward in time. Must be from 0 to 999,999,999 | ||
43 | // inclusive. | ||
44 | int32 nanos = 2; | ||
45 | } | ||
46 | |||
47 | service LoadBalancer { | ||
48 | // Bidirectional rpc to get a list of servers. | ||
49 | rpc BalanceLoad(stream LoadBalanceRequest) | ||
50 | returns (stream LoadBalanceResponse); | ||
51 | } | ||
52 | |||
53 | message LoadBalanceRequest { | ||
54 | oneof load_balance_request_type { | ||
55 | // This message should be sent on the first request to the load balancer. | ||
56 | InitialLoadBalanceRequest initial_request = 1; | ||
57 | |||
58 | // The client stats should be periodically reported to the load balancer | ||
59 | // based on the duration defined in the InitialLoadBalanceResponse. | ||
60 | ClientStats client_stats = 2; | ||
61 | } | ||
62 | } | ||
63 | |||
64 | message InitialLoadBalanceRequest { | ||
65 | // Name of load balanced service (IE, balancer.service.com) | ||
66 | // length should be less than 256 bytes. | ||
67 | string name = 1; | ||
68 | } | ||
69 | |||
70 | // Contains client level statistics that are useful to load balancing. Each | ||
71 | // count except the timestamp should be reset to zero after reporting the stats. | ||
72 | message ClientStats { | ||
73 | // The timestamp of generating the report. | ||
74 | Timestamp timestamp = 1; | ||
75 | |||
76 | // The total number of RPCs that started. | ||
77 | int64 num_calls_started = 2; | ||
78 | |||
79 | // The total number of RPCs that finished. | ||
80 | int64 num_calls_finished = 3; | ||
81 | |||
82 | // The total number of RPCs that were dropped by the client because of rate | ||
83 | // limiting. | ||
84 | int64 num_calls_finished_with_drop_for_rate_limiting = 4; | ||
85 | |||
86 | // The total number of RPCs that were dropped by the client because of load | ||
87 | // balancing. | ||
88 | int64 num_calls_finished_with_drop_for_load_balancing = 5; | ||
89 | |||
90 | // The total number of RPCs that failed to reach a server except dropped RPCs. | ||
91 | int64 num_calls_finished_with_client_failed_to_send = 6; | ||
92 | |||
93 | // The total number of RPCs that finished and are known to have been received | ||
94 | // by a server. | ||
95 | int64 num_calls_finished_known_received = 7; | ||
96 | } | ||
97 | |||
98 | message LoadBalanceResponse { | ||
99 | oneof load_balance_response_type { | ||
100 | // This message should be sent on the first response to the client. | ||
101 | InitialLoadBalanceResponse initial_response = 1; | ||
102 | |||
103 | // Contains the list of servers selected by the load balancer. The client | ||
104 | // should send requests to these servers in the specified order. | ||
105 | ServerList server_list = 2; | ||
106 | } | ||
107 | } | ||
108 | |||
109 | message InitialLoadBalanceResponse { | ||
110 | // This is an application layer redirect that indicates the client should use | ||
111 | // the specified server for load balancing. When this field is non-empty in | ||
112 | // the response, the client should open a separate connection to the | ||
113 | // load_balancer_delegate and call the BalanceLoad method. Its length should | ||
114 | // be less than 64 bytes. | ||
115 | string load_balancer_delegate = 1; | ||
116 | |||
117 | // This interval defines how often the client should send the client stats | ||
118 | // to the load balancer. Stats should only be reported when the duration is | ||
119 | // positive. | ||
120 | Duration client_stats_report_interval = 2; | ||
121 | } | ||
122 | |||
123 | message ServerList { | ||
124 | // Contains a list of servers selected by the load balancer. The list will | ||
125 | // be updated when server resolutions change or as needed to balance load | ||
126 | // across more servers. The client should consume the server list in order | ||
127 | // unless instructed otherwise via the client_config. | ||
128 | repeated Server servers = 1; | ||
129 | |||
130 | // Indicates the amount of time that the client should consider this server | ||
131 | // list as valid. It may be considered stale after waiting this interval of | ||
132 | // time after receiving the list. If the interval is not positive, the | ||
133 | // client can assume the list is valid until the next list is received. | ||
134 | Duration expiration_interval = 3; | ||
135 | } | ||
136 | |||
137 | // Contains server information. When none of the [drop_for_*] fields are true, | ||
138 | // use the other fields. When drop_for_rate_limiting is true, ignore all other | ||
139 | // fields. Use drop_for_load_balancing only when it is true and | ||
140 | // drop_for_rate_limiting is false. | ||
141 | message Server { | ||
142 | // A resolved address for the server, serialized in network-byte-order. It may | ||
143 | // either be an IPv4 or IPv6 address. | ||
144 | bytes ip_address = 1; | ||
145 | |||
146 | // A resolved port number for the server. | ||
147 | int32 port = 2; | ||
148 | |||
149 | // An opaque but printable token given to the frontend for each pick. All | ||
150 | // frontend requests for that pick must include the token in its initial | ||
151 | // metadata. The token is used by the backend to verify the request and to | ||
152 | // allow the backend to report load to the gRPC LB system. | ||
153 | // | ||
154 | // Its length is variable but less than 50 bytes. | ||
155 | string load_balance_token = 3; | ||
156 | |||
157 | // Indicates whether this particular request should be dropped by the client | ||
158 | // for rate limiting. | ||
159 | bool drop_for_rate_limiting = 4; | ||
160 | |||
161 | // Indicates whether this particular request should be dropped by the client | ||
162 | // for load balancing. | ||
163 | bool drop_for_load_balancing = 5; | ||
164 | } | ||