blob: 904c32187fb3f70de925f9b7fcf270ba1c54a4c7 [file] [log] [blame]
khenaidoo59ce9dd2019-11-11 13:05:32 -05001// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
2// source: etcdserver/etcdserverpb/rpc.proto
3
4/*
5Package etcdserverpb is a reverse proxy.
6
7It translates gRPC into RESTful JSON APIs.
8*/
9package gw
10
11import (
12 "go.etcd.io/etcd/etcdserver/etcdserverpb"
13 "io"
14 "net/http"
15
16 "github.com/golang/protobuf/proto"
17 "github.com/grpc-ecosystem/grpc-gateway/runtime"
18 "github.com/grpc-ecosystem/grpc-gateway/utilities"
19 "golang.org/x/net/context"
20 "google.golang.org/grpc"
21 "google.golang.org/grpc/codes"
22 "google.golang.org/grpc/grpclog"
23 "google.golang.org/grpc/status"
24)
25
26var _ codes.Code
27var _ io.Reader
28var _ status.Status
29var _ = runtime.String
30var _ = utilities.NewDoubleArray
31
32func request_KV_Range_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
33 var protoReq etcdserverpb.RangeRequest
34 var metadata runtime.ServerMetadata
35
36 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
37 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
38 }
39
40 msg, err := client.Range(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
41 return msg, metadata, err
42
43}
44
45func request_KV_Put_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
46 var protoReq etcdserverpb.PutRequest
47 var metadata runtime.ServerMetadata
48
49 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
50 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
51 }
52
53 msg, err := client.Put(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
54 return msg, metadata, err
55
56}
57
58func request_KV_DeleteRange_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
59 var protoReq etcdserverpb.DeleteRangeRequest
60 var metadata runtime.ServerMetadata
61
62 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
63 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
64 }
65
66 msg, err := client.DeleteRange(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
67 return msg, metadata, err
68
69}
70
71func request_KV_Txn_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
72 var protoReq etcdserverpb.TxnRequest
73 var metadata runtime.ServerMetadata
74
75 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
76 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
77 }
78
79 msg, err := client.Txn(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
80 return msg, metadata, err
81
82}
83
84func request_KV_Compact_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.KVClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
85 var protoReq etcdserverpb.CompactionRequest
86 var metadata runtime.ServerMetadata
87
88 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
89 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
90 }
91
92 msg, err := client.Compact(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
93 return msg, metadata, err
94
95}
96
97func request_Watch_Watch_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.WatchClient, req *http.Request, pathParams map[string]string) (etcdserverpb.Watch_WatchClient, runtime.ServerMetadata, error) {
98 var metadata runtime.ServerMetadata
99 stream, err := client.Watch(ctx)
100 if err != nil {
101 grpclog.Printf("Failed to start streaming: %v", err)
102 return nil, metadata, err
103 }
104 dec := marshaler.NewDecoder(req.Body)
105 handleSend := func() error {
106 var protoReq etcdserverpb.WatchRequest
107 err := dec.Decode(&protoReq)
108 if err == io.EOF {
109 return err
110 }
111 if err != nil {
112 grpclog.Printf("Failed to decode request: %v", err)
113 return err
114 }
115 if err := stream.Send(&protoReq); err != nil {
116 grpclog.Printf("Failed to send request: %v", err)
117 return err
118 }
119 return nil
120 }
121 if err := handleSend(); err != nil {
122 if cerr := stream.CloseSend(); cerr != nil {
123 grpclog.Printf("Failed to terminate client stream: %v", cerr)
124 }
125 if err == io.EOF {
126 return stream, metadata, nil
127 }
128 return nil, metadata, err
129 }
130 go func() {
131 for {
132 if err := handleSend(); err != nil {
133 break
134 }
135 }
136 if err := stream.CloseSend(); err != nil {
137 grpclog.Printf("Failed to terminate client stream: %v", err)
138 }
139 }()
140 header, err := stream.Header()
141 if err != nil {
142 grpclog.Printf("Failed to get header from client: %v", err)
143 return nil, metadata, err
144 }
145 metadata.HeaderMD = header
146 return stream, metadata, nil
147}
148
149func request_Lease_LeaseGrant_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
150 var protoReq etcdserverpb.LeaseGrantRequest
151 var metadata runtime.ServerMetadata
152
153 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
154 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
155 }
156
157 msg, err := client.LeaseGrant(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
158 return msg, metadata, err
159
160}
161
162func request_Lease_LeaseRevoke_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
163 var protoReq etcdserverpb.LeaseRevokeRequest
164 var metadata runtime.ServerMetadata
165
166 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
167 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
168 }
169
170 msg, err := client.LeaseRevoke(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
171 return msg, metadata, err
172
173}
174
175func request_Lease_LeaseRevoke_1(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
176 var protoReq etcdserverpb.LeaseRevokeRequest
177 var metadata runtime.ServerMetadata
178
179 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
180 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
181 }
182
183 msg, err := client.LeaseRevoke(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
184 return msg, metadata, err
185
186}
187
188func request_Lease_LeaseKeepAlive_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (etcdserverpb.Lease_LeaseKeepAliveClient, runtime.ServerMetadata, error) {
189 var metadata runtime.ServerMetadata
190 stream, err := client.LeaseKeepAlive(ctx)
191 if err != nil {
192 grpclog.Printf("Failed to start streaming: %v", err)
193 return nil, metadata, err
194 }
195 dec := marshaler.NewDecoder(req.Body)
196 handleSend := func() error {
197 var protoReq etcdserverpb.LeaseKeepAliveRequest
198 err := dec.Decode(&protoReq)
199 if err == io.EOF {
200 return err
201 }
202 if err != nil {
203 grpclog.Printf("Failed to decode request: %v", err)
204 return err
205 }
206 if err := stream.Send(&protoReq); err != nil {
207 grpclog.Printf("Failed to send request: %v", err)
208 return err
209 }
210 return nil
211 }
212 if err := handleSend(); err != nil {
213 if cerr := stream.CloseSend(); cerr != nil {
214 grpclog.Printf("Failed to terminate client stream: %v", cerr)
215 }
216 if err == io.EOF {
217 return stream, metadata, nil
218 }
219 return nil, metadata, err
220 }
221 go func() {
222 for {
223 if err := handleSend(); err != nil {
224 break
225 }
226 }
227 if err := stream.CloseSend(); err != nil {
228 grpclog.Printf("Failed to terminate client stream: %v", err)
229 }
230 }()
231 header, err := stream.Header()
232 if err != nil {
233 grpclog.Printf("Failed to get header from client: %v", err)
234 return nil, metadata, err
235 }
236 metadata.HeaderMD = header
237 return stream, metadata, nil
238}
239
240func request_Lease_LeaseTimeToLive_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
241 var protoReq etcdserverpb.LeaseTimeToLiveRequest
242 var metadata runtime.ServerMetadata
243
244 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
245 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
246 }
247
248 msg, err := client.LeaseTimeToLive(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
249 return msg, metadata, err
250
251}
252
253func request_Lease_LeaseTimeToLive_1(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
254 var protoReq etcdserverpb.LeaseTimeToLiveRequest
255 var metadata runtime.ServerMetadata
256
257 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
258 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
259 }
260
261 msg, err := client.LeaseTimeToLive(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
262 return msg, metadata, err
263
264}
265
266func request_Lease_LeaseLeases_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
267 var protoReq etcdserverpb.LeaseLeasesRequest
268 var metadata runtime.ServerMetadata
269
270 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
271 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
272 }
273
274 msg, err := client.LeaseLeases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
275 return msg, metadata, err
276
277}
278
279func request_Lease_LeaseLeases_1(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.LeaseClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
280 var protoReq etcdserverpb.LeaseLeasesRequest
281 var metadata runtime.ServerMetadata
282
283 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
284 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
285 }
286
287 msg, err := client.LeaseLeases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
288 return msg, metadata, err
289
290}
291
292func request_Cluster_MemberAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
293 var protoReq etcdserverpb.MemberAddRequest
294 var metadata runtime.ServerMetadata
295
296 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
297 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
298 }
299
300 msg, err := client.MemberAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
301 return msg, metadata, err
302
303}
304
305func request_Cluster_MemberRemove_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
306 var protoReq etcdserverpb.MemberRemoveRequest
307 var metadata runtime.ServerMetadata
308
309 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
310 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
311 }
312
313 msg, err := client.MemberRemove(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
314 return msg, metadata, err
315
316}
317
318func request_Cluster_MemberUpdate_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
319 var protoReq etcdserverpb.MemberUpdateRequest
320 var metadata runtime.ServerMetadata
321
322 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
323 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
324 }
325
326 msg, err := client.MemberUpdate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
327 return msg, metadata, err
328
329}
330
331func request_Cluster_MemberList_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
332 var protoReq etcdserverpb.MemberListRequest
333 var metadata runtime.ServerMetadata
334
335 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
336 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
337 }
338
339 msg, err := client.MemberList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
340 return msg, metadata, err
341
342}
343
344func request_Cluster_MemberPromote_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.ClusterClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
345 var protoReq etcdserverpb.MemberPromoteRequest
346 var metadata runtime.ServerMetadata
347
348 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
349 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
350 }
351
352 msg, err := client.MemberPromote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
353 return msg, metadata, err
354
355}
356
357func request_Maintenance_Alarm_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
358 var protoReq etcdserverpb.AlarmRequest
359 var metadata runtime.ServerMetadata
360
361 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
362 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
363 }
364
365 msg, err := client.Alarm(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
366 return msg, metadata, err
367
368}
369
370func request_Maintenance_Status_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
371 var protoReq etcdserverpb.StatusRequest
372 var metadata runtime.ServerMetadata
373
374 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
375 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
376 }
377
378 msg, err := client.Status(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
379 return msg, metadata, err
380
381}
382
383func request_Maintenance_Defragment_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
384 var protoReq etcdserverpb.DefragmentRequest
385 var metadata runtime.ServerMetadata
386
387 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
388 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
389 }
390
391 msg, err := client.Defragment(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
392 return msg, metadata, err
393
394}
395
396func request_Maintenance_Hash_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
397 var protoReq etcdserverpb.HashRequest
398 var metadata runtime.ServerMetadata
399
400 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
401 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
402 }
403
404 msg, err := client.Hash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
405 return msg, metadata, err
406
407}
408
409func request_Maintenance_HashKV_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
410 var protoReq etcdserverpb.HashKVRequest
411 var metadata runtime.ServerMetadata
412
413 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
414 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
415 }
416
417 msg, err := client.HashKV(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
418 return msg, metadata, err
419
420}
421
422func request_Maintenance_Snapshot_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (etcdserverpb.Maintenance_SnapshotClient, runtime.ServerMetadata, error) {
423 var protoReq etcdserverpb.SnapshotRequest
424 var metadata runtime.ServerMetadata
425
426 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
427 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
428 }
429
430 stream, err := client.Snapshot(ctx, &protoReq)
431 if err != nil {
432 return nil, metadata, err
433 }
434 header, err := stream.Header()
435 if err != nil {
436 return nil, metadata, err
437 }
438 metadata.HeaderMD = header
439 return stream, metadata, nil
440
441}
442
443func request_Maintenance_MoveLeader_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
444 var protoReq etcdserverpb.MoveLeaderRequest
445 var metadata runtime.ServerMetadata
446
447 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
448 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
449 }
450
451 msg, err := client.MoveLeader(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
452 return msg, metadata, err
453
454}
455
456func request_Auth_AuthEnable_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
457 var protoReq etcdserverpb.AuthEnableRequest
458 var metadata runtime.ServerMetadata
459
460 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
461 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
462 }
463
464 msg, err := client.AuthEnable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
465 return msg, metadata, err
466
467}
468
469func request_Auth_AuthDisable_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
470 var protoReq etcdserverpb.AuthDisableRequest
471 var metadata runtime.ServerMetadata
472
473 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
474 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
475 }
476
477 msg, err := client.AuthDisable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
478 return msg, metadata, err
479
480}
481
482func request_Auth_Authenticate_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
483 var protoReq etcdserverpb.AuthenticateRequest
484 var metadata runtime.ServerMetadata
485
486 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
487 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
488 }
489
490 msg, err := client.Authenticate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
491 return msg, metadata, err
492
493}
494
495func request_Auth_UserAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
496 var protoReq etcdserverpb.AuthUserAddRequest
497 var metadata runtime.ServerMetadata
498
499 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
500 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
501 }
502
503 msg, err := client.UserAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
504 return msg, metadata, err
505
506}
507
508func request_Auth_UserGet_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
509 var protoReq etcdserverpb.AuthUserGetRequest
510 var metadata runtime.ServerMetadata
511
512 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
513 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
514 }
515
516 msg, err := client.UserGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
517 return msg, metadata, err
518
519}
520
521func request_Auth_UserList_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
522 var protoReq etcdserverpb.AuthUserListRequest
523 var metadata runtime.ServerMetadata
524
525 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
526 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
527 }
528
529 msg, err := client.UserList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
530 return msg, metadata, err
531
532}
533
534func request_Auth_UserDelete_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
535 var protoReq etcdserverpb.AuthUserDeleteRequest
536 var metadata runtime.ServerMetadata
537
538 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
539 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
540 }
541
542 msg, err := client.UserDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
543 return msg, metadata, err
544
545}
546
547func request_Auth_UserChangePassword_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
548 var protoReq etcdserverpb.AuthUserChangePasswordRequest
549 var metadata runtime.ServerMetadata
550
551 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
552 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
553 }
554
555 msg, err := client.UserChangePassword(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
556 return msg, metadata, err
557
558}
559
560func request_Auth_UserGrantRole_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
561 var protoReq etcdserverpb.AuthUserGrantRoleRequest
562 var metadata runtime.ServerMetadata
563
564 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
565 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
566 }
567
568 msg, err := client.UserGrantRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
569 return msg, metadata, err
570
571}
572
573func request_Auth_UserRevokeRole_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
574 var protoReq etcdserverpb.AuthUserRevokeRoleRequest
575 var metadata runtime.ServerMetadata
576
577 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
578 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
579 }
580
581 msg, err := client.UserRevokeRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
582 return msg, metadata, err
583
584}
585
586func request_Auth_RoleAdd_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
587 var protoReq etcdserverpb.AuthRoleAddRequest
588 var metadata runtime.ServerMetadata
589
590 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
591 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
592 }
593
594 msg, err := client.RoleAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
595 return msg, metadata, err
596
597}
598
599func request_Auth_RoleGet_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
600 var protoReq etcdserverpb.AuthRoleGetRequest
601 var metadata runtime.ServerMetadata
602
603 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
604 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
605 }
606
607 msg, err := client.RoleGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
608 return msg, metadata, err
609
610}
611
612func request_Auth_RoleList_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
613 var protoReq etcdserverpb.AuthRoleListRequest
614 var metadata runtime.ServerMetadata
615
616 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
617 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
618 }
619
620 msg, err := client.RoleList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
621 return msg, metadata, err
622
623}
624
625func request_Auth_RoleDelete_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
626 var protoReq etcdserverpb.AuthRoleDeleteRequest
627 var metadata runtime.ServerMetadata
628
629 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
630 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
631 }
632
633 msg, err := client.RoleDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
634 return msg, metadata, err
635
636}
637
638func request_Auth_RoleGrantPermission_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
639 var protoReq etcdserverpb.AuthRoleGrantPermissionRequest
640 var metadata runtime.ServerMetadata
641
642 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
643 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
644 }
645
646 msg, err := client.RoleGrantPermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
647 return msg, metadata, err
648
649}
650
651func request_Auth_RoleRevokePermission_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
652 var protoReq etcdserverpb.AuthRoleRevokePermissionRequest
653 var metadata runtime.ServerMetadata
654
655 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF {
656 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
657 }
658
659 msg, err := client.RoleRevokePermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
660 return msg, metadata, err
661
662}
663
664// RegisterKVHandlerFromEndpoint is same as RegisterKVHandler but
665// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
666func RegisterKVHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
667 conn, err := grpc.Dial(endpoint, opts...)
668 if err != nil {
669 return err
670 }
671 defer func() {
672 if err != nil {
673 if cerr := conn.Close(); cerr != nil {
674 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
675 }
676 return
677 }
678 go func() {
679 <-ctx.Done()
680 if cerr := conn.Close(); cerr != nil {
681 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
682 }
683 }()
684 }()
685
686 return RegisterKVHandler(ctx, mux, conn)
687}
688
689// RegisterKVHandler registers the http handlers for service KV to "mux".
690// The handlers forward requests to the grpc endpoint over "conn".
691func RegisterKVHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
692 return RegisterKVHandlerClient(ctx, mux, etcdserverpb.NewKVClient(conn))
693}
694
695// RegisterKVHandler registers the http handlers for service KV to "mux".
696// The handlers forward requests to the grpc endpoint over the given implementation of "KVClient".
697// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "KVClient"
698// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
699// "KVClient" to call the correct interceptors.
700func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.KVClient) error {
701
702 mux.Handle("POST", pattern_KV_Range_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
703 ctx, cancel := context.WithCancel(req.Context())
704 defer cancel()
705 if cn, ok := w.(http.CloseNotifier); ok {
706 go func(done <-chan struct{}, closed <-chan bool) {
707 select {
708 case <-done:
709 case <-closed:
710 cancel()
711 }
712 }(ctx.Done(), cn.CloseNotify())
713 }
714 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
715 rctx, err := runtime.AnnotateContext(ctx, mux, req)
716 if err != nil {
717 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
718 return
719 }
720 resp, md, err := request_KV_Range_0(rctx, inboundMarshaler, client, req, pathParams)
721 ctx = runtime.NewServerMetadataContext(ctx, md)
722 if err != nil {
723 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
724 return
725 }
726
727 forward_KV_Range_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
728
729 })
730
731 mux.Handle("POST", pattern_KV_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
732 ctx, cancel := context.WithCancel(req.Context())
733 defer cancel()
734 if cn, ok := w.(http.CloseNotifier); ok {
735 go func(done <-chan struct{}, closed <-chan bool) {
736 select {
737 case <-done:
738 case <-closed:
739 cancel()
740 }
741 }(ctx.Done(), cn.CloseNotify())
742 }
743 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
744 rctx, err := runtime.AnnotateContext(ctx, mux, req)
745 if err != nil {
746 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
747 return
748 }
749 resp, md, err := request_KV_Put_0(rctx, inboundMarshaler, client, req, pathParams)
750 ctx = runtime.NewServerMetadataContext(ctx, md)
751 if err != nil {
752 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
753 return
754 }
755
756 forward_KV_Put_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
757
758 })
759
760 mux.Handle("POST", pattern_KV_DeleteRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
761 ctx, cancel := context.WithCancel(req.Context())
762 defer cancel()
763 if cn, ok := w.(http.CloseNotifier); ok {
764 go func(done <-chan struct{}, closed <-chan bool) {
765 select {
766 case <-done:
767 case <-closed:
768 cancel()
769 }
770 }(ctx.Done(), cn.CloseNotify())
771 }
772 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
773 rctx, err := runtime.AnnotateContext(ctx, mux, req)
774 if err != nil {
775 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
776 return
777 }
778 resp, md, err := request_KV_DeleteRange_0(rctx, inboundMarshaler, client, req, pathParams)
779 ctx = runtime.NewServerMetadataContext(ctx, md)
780 if err != nil {
781 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
782 return
783 }
784
785 forward_KV_DeleteRange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
786
787 })
788
789 mux.Handle("POST", pattern_KV_Txn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
790 ctx, cancel := context.WithCancel(req.Context())
791 defer cancel()
792 if cn, ok := w.(http.CloseNotifier); ok {
793 go func(done <-chan struct{}, closed <-chan bool) {
794 select {
795 case <-done:
796 case <-closed:
797 cancel()
798 }
799 }(ctx.Done(), cn.CloseNotify())
800 }
801 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
802 rctx, err := runtime.AnnotateContext(ctx, mux, req)
803 if err != nil {
804 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
805 return
806 }
807 resp, md, err := request_KV_Txn_0(rctx, inboundMarshaler, client, req, pathParams)
808 ctx = runtime.NewServerMetadataContext(ctx, md)
809 if err != nil {
810 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
811 return
812 }
813
814 forward_KV_Txn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
815
816 })
817
818 mux.Handle("POST", pattern_KV_Compact_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
819 ctx, cancel := context.WithCancel(req.Context())
820 defer cancel()
821 if cn, ok := w.(http.CloseNotifier); ok {
822 go func(done <-chan struct{}, closed <-chan bool) {
823 select {
824 case <-done:
825 case <-closed:
826 cancel()
827 }
828 }(ctx.Done(), cn.CloseNotify())
829 }
830 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
831 rctx, err := runtime.AnnotateContext(ctx, mux, req)
832 if err != nil {
833 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
834 return
835 }
836 resp, md, err := request_KV_Compact_0(rctx, inboundMarshaler, client, req, pathParams)
837 ctx = runtime.NewServerMetadataContext(ctx, md)
838 if err != nil {
839 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
840 return
841 }
842
843 forward_KV_Compact_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
844
845 })
846
847 return nil
848}
849
850var (
851 pattern_KV_Range_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "range"}, ""))
852
853 pattern_KV_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "put"}, ""))
854
855 pattern_KV_DeleteRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "deleterange"}, ""))
856
857 pattern_KV_Txn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "txn"}, ""))
858
859 pattern_KV_Compact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "compaction"}, ""))
860)
861
862var (
863 forward_KV_Range_0 = runtime.ForwardResponseMessage
864
865 forward_KV_Put_0 = runtime.ForwardResponseMessage
866
867 forward_KV_DeleteRange_0 = runtime.ForwardResponseMessage
868
869 forward_KV_Txn_0 = runtime.ForwardResponseMessage
870
871 forward_KV_Compact_0 = runtime.ForwardResponseMessage
872)
873
874// RegisterWatchHandlerFromEndpoint is same as RegisterWatchHandler but
875// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
876func RegisterWatchHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
877 conn, err := grpc.Dial(endpoint, opts...)
878 if err != nil {
879 return err
880 }
881 defer func() {
882 if err != nil {
883 if cerr := conn.Close(); cerr != nil {
884 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
885 }
886 return
887 }
888 go func() {
889 <-ctx.Done()
890 if cerr := conn.Close(); cerr != nil {
891 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
892 }
893 }()
894 }()
895
896 return RegisterWatchHandler(ctx, mux, conn)
897}
898
899// RegisterWatchHandler registers the http handlers for service Watch to "mux".
900// The handlers forward requests to the grpc endpoint over "conn".
901func RegisterWatchHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
902 return RegisterWatchHandlerClient(ctx, mux, etcdserverpb.NewWatchClient(conn))
903}
904
905// RegisterWatchHandler registers the http handlers for service Watch to "mux".
906// The handlers forward requests to the grpc endpoint over the given implementation of "WatchClient".
907// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WatchClient"
908// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
909// "WatchClient" to call the correct interceptors.
910func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.WatchClient) error {
911
912 mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
913 ctx, cancel := context.WithCancel(req.Context())
914 defer cancel()
915 if cn, ok := w.(http.CloseNotifier); ok {
916 go func(done <-chan struct{}, closed <-chan bool) {
917 select {
918 case <-done:
919 case <-closed:
920 cancel()
921 }
922 }(ctx.Done(), cn.CloseNotify())
923 }
924 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
925 rctx, err := runtime.AnnotateContext(ctx, mux, req)
926 if err != nil {
927 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
928 return
929 }
930 resp, md, err := request_Watch_Watch_0(rctx, inboundMarshaler, client, req, pathParams)
931 ctx = runtime.NewServerMetadataContext(ctx, md)
932 if err != nil {
933 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
934 return
935 }
936
937 forward_Watch_Watch_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
938
939 })
940
941 return nil
942}
943
944var (
945 pattern_Watch_Watch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v3", "watch"}, ""))
946)
947
948var (
949 forward_Watch_Watch_0 = runtime.ForwardResponseStream
950)
951
952// RegisterLeaseHandlerFromEndpoint is same as RegisterLeaseHandler but
953// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
954func RegisterLeaseHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
955 conn, err := grpc.Dial(endpoint, opts...)
956 if err != nil {
957 return err
958 }
959 defer func() {
960 if err != nil {
961 if cerr := conn.Close(); cerr != nil {
962 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
963 }
964 return
965 }
966 go func() {
967 <-ctx.Done()
968 if cerr := conn.Close(); cerr != nil {
969 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
970 }
971 }()
972 }()
973
974 return RegisterLeaseHandler(ctx, mux, conn)
975}
976
977// RegisterLeaseHandler registers the http handlers for service Lease to "mux".
978// The handlers forward requests to the grpc endpoint over "conn".
979func RegisterLeaseHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
980 return RegisterLeaseHandlerClient(ctx, mux, etcdserverpb.NewLeaseClient(conn))
981}
982
983// RegisterLeaseHandler registers the http handlers for service Lease to "mux".
984// The handlers forward requests to the grpc endpoint over the given implementation of "LeaseClient".
985// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LeaseClient"
986// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
987// "LeaseClient" to call the correct interceptors.
988func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.LeaseClient) error {
989
990 mux.Handle("POST", pattern_Lease_LeaseGrant_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
991 ctx, cancel := context.WithCancel(req.Context())
992 defer cancel()
993 if cn, ok := w.(http.CloseNotifier); ok {
994 go func(done <-chan struct{}, closed <-chan bool) {
995 select {
996 case <-done:
997 case <-closed:
998 cancel()
999 }
1000 }(ctx.Done(), cn.CloseNotify())
1001 }
1002 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1003 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1004 if err != nil {
1005 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1006 return
1007 }
1008 resp, md, err := request_Lease_LeaseGrant_0(rctx, inboundMarshaler, client, req, pathParams)
1009 ctx = runtime.NewServerMetadataContext(ctx, md)
1010 if err != nil {
1011 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1012 return
1013 }
1014
1015 forward_Lease_LeaseGrant_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1016
1017 })
1018
1019 mux.Handle("POST", pattern_Lease_LeaseRevoke_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1020 ctx, cancel := context.WithCancel(req.Context())
1021 defer cancel()
1022 if cn, ok := w.(http.CloseNotifier); ok {
1023 go func(done <-chan struct{}, closed <-chan bool) {
1024 select {
1025 case <-done:
1026 case <-closed:
1027 cancel()
1028 }
1029 }(ctx.Done(), cn.CloseNotify())
1030 }
1031 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1032 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1033 if err != nil {
1034 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1035 return
1036 }
1037 resp, md, err := request_Lease_LeaseRevoke_0(rctx, inboundMarshaler, client, req, pathParams)
1038 ctx = runtime.NewServerMetadataContext(ctx, md)
1039 if err != nil {
1040 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1041 return
1042 }
1043
1044 forward_Lease_LeaseRevoke_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1045
1046 })
1047
1048 mux.Handle("POST", pattern_Lease_LeaseRevoke_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1049 ctx, cancel := context.WithCancel(req.Context())
1050 defer cancel()
1051 if cn, ok := w.(http.CloseNotifier); ok {
1052 go func(done <-chan struct{}, closed <-chan bool) {
1053 select {
1054 case <-done:
1055 case <-closed:
1056 cancel()
1057 }
1058 }(ctx.Done(), cn.CloseNotify())
1059 }
1060 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1061 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1062 if err != nil {
1063 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1064 return
1065 }
1066 resp, md, err := request_Lease_LeaseRevoke_1(rctx, inboundMarshaler, client, req, pathParams)
1067 ctx = runtime.NewServerMetadataContext(ctx, md)
1068 if err != nil {
1069 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1070 return
1071 }
1072
1073 forward_Lease_LeaseRevoke_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1074
1075 })
1076
1077 mux.Handle("POST", pattern_Lease_LeaseKeepAlive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1078 ctx, cancel := context.WithCancel(req.Context())
1079 defer cancel()
1080 if cn, ok := w.(http.CloseNotifier); ok {
1081 go func(done <-chan struct{}, closed <-chan bool) {
1082 select {
1083 case <-done:
1084 case <-closed:
1085 cancel()
1086 }
1087 }(ctx.Done(), cn.CloseNotify())
1088 }
1089 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1090 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1091 if err != nil {
1092 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1093 return
1094 }
1095 resp, md, err := request_Lease_LeaseKeepAlive_0(rctx, inboundMarshaler, client, req, pathParams)
1096 ctx = runtime.NewServerMetadataContext(ctx, md)
1097 if err != nil {
1098 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1099 return
1100 }
1101
1102 forward_Lease_LeaseKeepAlive_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
1103
1104 })
1105
1106 mux.Handle("POST", pattern_Lease_LeaseTimeToLive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1107 ctx, cancel := context.WithCancel(req.Context())
1108 defer cancel()
1109 if cn, ok := w.(http.CloseNotifier); ok {
1110 go func(done <-chan struct{}, closed <-chan bool) {
1111 select {
1112 case <-done:
1113 case <-closed:
1114 cancel()
1115 }
1116 }(ctx.Done(), cn.CloseNotify())
1117 }
1118 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1119 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1120 if err != nil {
1121 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1122 return
1123 }
1124 resp, md, err := request_Lease_LeaseTimeToLive_0(rctx, inboundMarshaler, client, req, pathParams)
1125 ctx = runtime.NewServerMetadataContext(ctx, md)
1126 if err != nil {
1127 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1128 return
1129 }
1130
1131 forward_Lease_LeaseTimeToLive_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1132
1133 })
1134
1135 mux.Handle("POST", pattern_Lease_LeaseTimeToLive_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1136 ctx, cancel := context.WithCancel(req.Context())
1137 defer cancel()
1138 if cn, ok := w.(http.CloseNotifier); ok {
1139 go func(done <-chan struct{}, closed <-chan bool) {
1140 select {
1141 case <-done:
1142 case <-closed:
1143 cancel()
1144 }
1145 }(ctx.Done(), cn.CloseNotify())
1146 }
1147 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1148 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1149 if err != nil {
1150 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1151 return
1152 }
1153 resp, md, err := request_Lease_LeaseTimeToLive_1(rctx, inboundMarshaler, client, req, pathParams)
1154 ctx = runtime.NewServerMetadataContext(ctx, md)
1155 if err != nil {
1156 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1157 return
1158 }
1159
1160 forward_Lease_LeaseTimeToLive_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1161
1162 })
1163
1164 mux.Handle("POST", pattern_Lease_LeaseLeases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1165 ctx, cancel := context.WithCancel(req.Context())
1166 defer cancel()
1167 if cn, ok := w.(http.CloseNotifier); ok {
1168 go func(done <-chan struct{}, closed <-chan bool) {
1169 select {
1170 case <-done:
1171 case <-closed:
1172 cancel()
1173 }
1174 }(ctx.Done(), cn.CloseNotify())
1175 }
1176 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1177 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1178 if err != nil {
1179 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1180 return
1181 }
1182 resp, md, err := request_Lease_LeaseLeases_0(rctx, inboundMarshaler, client, req, pathParams)
1183 ctx = runtime.NewServerMetadataContext(ctx, md)
1184 if err != nil {
1185 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1186 return
1187 }
1188
1189 forward_Lease_LeaseLeases_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1190
1191 })
1192
1193 mux.Handle("POST", pattern_Lease_LeaseLeases_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1194 ctx, cancel := context.WithCancel(req.Context())
1195 defer cancel()
1196 if cn, ok := w.(http.CloseNotifier); ok {
1197 go func(done <-chan struct{}, closed <-chan bool) {
1198 select {
1199 case <-done:
1200 case <-closed:
1201 cancel()
1202 }
1203 }(ctx.Done(), cn.CloseNotify())
1204 }
1205 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1206 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1207 if err != nil {
1208 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1209 return
1210 }
1211 resp, md, err := request_Lease_LeaseLeases_1(rctx, inboundMarshaler, client, req, pathParams)
1212 ctx = runtime.NewServerMetadataContext(ctx, md)
1213 if err != nil {
1214 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1215 return
1216 }
1217
1218 forward_Lease_LeaseLeases_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1219
1220 })
1221
1222 return nil
1223}
1224
1225var (
1226 pattern_Lease_LeaseGrant_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "grant"}, ""))
1227
1228 pattern_Lease_LeaseRevoke_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "revoke"}, ""))
1229
1230 pattern_Lease_LeaseRevoke_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "kv", "lease", "revoke"}, ""))
1231
1232 pattern_Lease_LeaseKeepAlive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "keepalive"}, ""))
1233
1234 pattern_Lease_LeaseTimeToLive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "timetolive"}, ""))
1235
1236 pattern_Lease_LeaseTimeToLive_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "kv", "lease", "timetolive"}, ""))
1237
1238 pattern_Lease_LeaseLeases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "leases"}, ""))
1239
1240 pattern_Lease_LeaseLeases_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "kv", "lease", "leases"}, ""))
1241)
1242
1243var (
1244 forward_Lease_LeaseGrant_0 = runtime.ForwardResponseMessage
1245
1246 forward_Lease_LeaseRevoke_0 = runtime.ForwardResponseMessage
1247
1248 forward_Lease_LeaseRevoke_1 = runtime.ForwardResponseMessage
1249
1250 forward_Lease_LeaseKeepAlive_0 = runtime.ForwardResponseStream
1251
1252 forward_Lease_LeaseTimeToLive_0 = runtime.ForwardResponseMessage
1253
1254 forward_Lease_LeaseTimeToLive_1 = runtime.ForwardResponseMessage
1255
1256 forward_Lease_LeaseLeases_0 = runtime.ForwardResponseMessage
1257
1258 forward_Lease_LeaseLeases_1 = runtime.ForwardResponseMessage
1259)
1260
1261// RegisterClusterHandlerFromEndpoint is same as RegisterClusterHandler but
1262// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
1263func RegisterClusterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
1264 conn, err := grpc.Dial(endpoint, opts...)
1265 if err != nil {
1266 return err
1267 }
1268 defer func() {
1269 if err != nil {
1270 if cerr := conn.Close(); cerr != nil {
1271 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
1272 }
1273 return
1274 }
1275 go func() {
1276 <-ctx.Done()
1277 if cerr := conn.Close(); cerr != nil {
1278 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
1279 }
1280 }()
1281 }()
1282
1283 return RegisterClusterHandler(ctx, mux, conn)
1284}
1285
1286// RegisterClusterHandler registers the http handlers for service Cluster to "mux".
1287// The handlers forward requests to the grpc endpoint over "conn".
1288func RegisterClusterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
1289 return RegisterClusterHandlerClient(ctx, mux, etcdserverpb.NewClusterClient(conn))
1290}
1291
1292// RegisterClusterHandler registers the http handlers for service Cluster to "mux".
1293// The handlers forward requests to the grpc endpoint over the given implementation of "ClusterClient".
1294// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ClusterClient"
1295// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
1296// "ClusterClient" to call the correct interceptors.
1297func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.ClusterClient) error {
1298
1299 mux.Handle("POST", pattern_Cluster_MemberAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1300 ctx, cancel := context.WithCancel(req.Context())
1301 defer cancel()
1302 if cn, ok := w.(http.CloseNotifier); ok {
1303 go func(done <-chan struct{}, closed <-chan bool) {
1304 select {
1305 case <-done:
1306 case <-closed:
1307 cancel()
1308 }
1309 }(ctx.Done(), cn.CloseNotify())
1310 }
1311 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1312 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1313 if err != nil {
1314 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1315 return
1316 }
1317 resp, md, err := request_Cluster_MemberAdd_0(rctx, inboundMarshaler, client, req, pathParams)
1318 ctx = runtime.NewServerMetadataContext(ctx, md)
1319 if err != nil {
1320 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1321 return
1322 }
1323
1324 forward_Cluster_MemberAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1325
1326 })
1327
1328 mux.Handle("POST", pattern_Cluster_MemberRemove_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1329 ctx, cancel := context.WithCancel(req.Context())
1330 defer cancel()
1331 if cn, ok := w.(http.CloseNotifier); ok {
1332 go func(done <-chan struct{}, closed <-chan bool) {
1333 select {
1334 case <-done:
1335 case <-closed:
1336 cancel()
1337 }
1338 }(ctx.Done(), cn.CloseNotify())
1339 }
1340 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1341 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1342 if err != nil {
1343 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1344 return
1345 }
1346 resp, md, err := request_Cluster_MemberRemove_0(rctx, inboundMarshaler, client, req, pathParams)
1347 ctx = runtime.NewServerMetadataContext(ctx, md)
1348 if err != nil {
1349 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1350 return
1351 }
1352
1353 forward_Cluster_MemberRemove_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1354
1355 })
1356
1357 mux.Handle("POST", pattern_Cluster_MemberUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1358 ctx, cancel := context.WithCancel(req.Context())
1359 defer cancel()
1360 if cn, ok := w.(http.CloseNotifier); ok {
1361 go func(done <-chan struct{}, closed <-chan bool) {
1362 select {
1363 case <-done:
1364 case <-closed:
1365 cancel()
1366 }
1367 }(ctx.Done(), cn.CloseNotify())
1368 }
1369 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1370 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1371 if err != nil {
1372 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1373 return
1374 }
1375 resp, md, err := request_Cluster_MemberUpdate_0(rctx, inboundMarshaler, client, req, pathParams)
1376 ctx = runtime.NewServerMetadataContext(ctx, md)
1377 if err != nil {
1378 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1379 return
1380 }
1381
1382 forward_Cluster_MemberUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1383
1384 })
1385
1386 mux.Handle("POST", pattern_Cluster_MemberList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1387 ctx, cancel := context.WithCancel(req.Context())
1388 defer cancel()
1389 if cn, ok := w.(http.CloseNotifier); ok {
1390 go func(done <-chan struct{}, closed <-chan bool) {
1391 select {
1392 case <-done:
1393 case <-closed:
1394 cancel()
1395 }
1396 }(ctx.Done(), cn.CloseNotify())
1397 }
1398 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1399 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1400 if err != nil {
1401 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1402 return
1403 }
1404 resp, md, err := request_Cluster_MemberList_0(rctx, inboundMarshaler, client, req, pathParams)
1405 ctx = runtime.NewServerMetadataContext(ctx, md)
1406 if err != nil {
1407 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1408 return
1409 }
1410
1411 forward_Cluster_MemberList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1412
1413 })
1414
1415 mux.Handle("POST", pattern_Cluster_MemberPromote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1416 ctx, cancel := context.WithCancel(req.Context())
1417 defer cancel()
1418 if cn, ok := w.(http.CloseNotifier); ok {
1419 go func(done <-chan struct{}, closed <-chan bool) {
1420 select {
1421 case <-done:
1422 case <-closed:
1423 cancel()
1424 }
1425 }(ctx.Done(), cn.CloseNotify())
1426 }
1427 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1428 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1429 if err != nil {
1430 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1431 return
1432 }
1433 resp, md, err := request_Cluster_MemberPromote_0(rctx, inboundMarshaler, client, req, pathParams)
1434 ctx = runtime.NewServerMetadataContext(ctx, md)
1435 if err != nil {
1436 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1437 return
1438 }
1439
1440 forward_Cluster_MemberPromote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1441
1442 })
1443
1444 return nil
1445}
1446
1447var (
1448 pattern_Cluster_MemberAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "add"}, ""))
1449
1450 pattern_Cluster_MemberRemove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "remove"}, ""))
1451
1452 pattern_Cluster_MemberUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "update"}, ""))
1453
1454 pattern_Cluster_MemberList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "list"}, ""))
1455
1456 pattern_Cluster_MemberPromote_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "promote"}, ""))
1457)
1458
1459var (
1460 forward_Cluster_MemberAdd_0 = runtime.ForwardResponseMessage
1461
1462 forward_Cluster_MemberRemove_0 = runtime.ForwardResponseMessage
1463
1464 forward_Cluster_MemberUpdate_0 = runtime.ForwardResponseMessage
1465
1466 forward_Cluster_MemberList_0 = runtime.ForwardResponseMessage
1467
1468 forward_Cluster_MemberPromote_0 = runtime.ForwardResponseMessage
1469)
1470
1471// RegisterMaintenanceHandlerFromEndpoint is same as RegisterMaintenanceHandler but
1472// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
1473func RegisterMaintenanceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
1474 conn, err := grpc.Dial(endpoint, opts...)
1475 if err != nil {
1476 return err
1477 }
1478 defer func() {
1479 if err != nil {
1480 if cerr := conn.Close(); cerr != nil {
1481 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
1482 }
1483 return
1484 }
1485 go func() {
1486 <-ctx.Done()
1487 if cerr := conn.Close(); cerr != nil {
1488 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
1489 }
1490 }()
1491 }()
1492
1493 return RegisterMaintenanceHandler(ctx, mux, conn)
1494}
1495
1496// RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux".
1497// The handlers forward requests to the grpc endpoint over "conn".
1498func RegisterMaintenanceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
1499 return RegisterMaintenanceHandlerClient(ctx, mux, etcdserverpb.NewMaintenanceClient(conn))
1500}
1501
1502// RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux".
1503// The handlers forward requests to the grpc endpoint over the given implementation of "MaintenanceClient".
1504// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MaintenanceClient"
1505// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
1506// "MaintenanceClient" to call the correct interceptors.
1507func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.MaintenanceClient) error {
1508
1509 mux.Handle("POST", pattern_Maintenance_Alarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1510 ctx, cancel := context.WithCancel(req.Context())
1511 defer cancel()
1512 if cn, ok := w.(http.CloseNotifier); ok {
1513 go func(done <-chan struct{}, closed <-chan bool) {
1514 select {
1515 case <-done:
1516 case <-closed:
1517 cancel()
1518 }
1519 }(ctx.Done(), cn.CloseNotify())
1520 }
1521 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1522 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1523 if err != nil {
1524 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1525 return
1526 }
1527 resp, md, err := request_Maintenance_Alarm_0(rctx, inboundMarshaler, client, req, pathParams)
1528 ctx = runtime.NewServerMetadataContext(ctx, md)
1529 if err != nil {
1530 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1531 return
1532 }
1533
1534 forward_Maintenance_Alarm_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1535
1536 })
1537
1538 mux.Handle("POST", pattern_Maintenance_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1539 ctx, cancel := context.WithCancel(req.Context())
1540 defer cancel()
1541 if cn, ok := w.(http.CloseNotifier); ok {
1542 go func(done <-chan struct{}, closed <-chan bool) {
1543 select {
1544 case <-done:
1545 case <-closed:
1546 cancel()
1547 }
1548 }(ctx.Done(), cn.CloseNotify())
1549 }
1550 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1551 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1552 if err != nil {
1553 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1554 return
1555 }
1556 resp, md, err := request_Maintenance_Status_0(rctx, inboundMarshaler, client, req, pathParams)
1557 ctx = runtime.NewServerMetadataContext(ctx, md)
1558 if err != nil {
1559 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1560 return
1561 }
1562
1563 forward_Maintenance_Status_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1564
1565 })
1566
1567 mux.Handle("POST", pattern_Maintenance_Defragment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1568 ctx, cancel := context.WithCancel(req.Context())
1569 defer cancel()
1570 if cn, ok := w.(http.CloseNotifier); ok {
1571 go func(done <-chan struct{}, closed <-chan bool) {
1572 select {
1573 case <-done:
1574 case <-closed:
1575 cancel()
1576 }
1577 }(ctx.Done(), cn.CloseNotify())
1578 }
1579 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1580 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1581 if err != nil {
1582 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1583 return
1584 }
1585 resp, md, err := request_Maintenance_Defragment_0(rctx, inboundMarshaler, client, req, pathParams)
1586 ctx = runtime.NewServerMetadataContext(ctx, md)
1587 if err != nil {
1588 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1589 return
1590 }
1591
1592 forward_Maintenance_Defragment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1593
1594 })
1595
1596 mux.Handle("POST", pattern_Maintenance_Hash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1597 ctx, cancel := context.WithCancel(req.Context())
1598 defer cancel()
1599 if cn, ok := w.(http.CloseNotifier); ok {
1600 go func(done <-chan struct{}, closed <-chan bool) {
1601 select {
1602 case <-done:
1603 case <-closed:
1604 cancel()
1605 }
1606 }(ctx.Done(), cn.CloseNotify())
1607 }
1608 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1609 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1610 if err != nil {
1611 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1612 return
1613 }
1614 resp, md, err := request_Maintenance_Hash_0(rctx, inboundMarshaler, client, req, pathParams)
1615 ctx = runtime.NewServerMetadataContext(ctx, md)
1616 if err != nil {
1617 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1618 return
1619 }
1620
1621 forward_Maintenance_Hash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1622
1623 })
1624
1625 mux.Handle("POST", pattern_Maintenance_HashKV_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1626 ctx, cancel := context.WithCancel(req.Context())
1627 defer cancel()
1628 if cn, ok := w.(http.CloseNotifier); ok {
1629 go func(done <-chan struct{}, closed <-chan bool) {
1630 select {
1631 case <-done:
1632 case <-closed:
1633 cancel()
1634 }
1635 }(ctx.Done(), cn.CloseNotify())
1636 }
1637 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1638 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1639 if err != nil {
1640 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1641 return
1642 }
1643 resp, md, err := request_Maintenance_HashKV_0(rctx, inboundMarshaler, client, req, pathParams)
1644 ctx = runtime.NewServerMetadataContext(ctx, md)
1645 if err != nil {
1646 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1647 return
1648 }
1649
1650 forward_Maintenance_HashKV_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1651
1652 })
1653
1654 mux.Handle("POST", pattern_Maintenance_Snapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1655 ctx, cancel := context.WithCancel(req.Context())
1656 defer cancel()
1657 if cn, ok := w.(http.CloseNotifier); ok {
1658 go func(done <-chan struct{}, closed <-chan bool) {
1659 select {
1660 case <-done:
1661 case <-closed:
1662 cancel()
1663 }
1664 }(ctx.Done(), cn.CloseNotify())
1665 }
1666 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1667 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1668 if err != nil {
1669 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1670 return
1671 }
1672 resp, md, err := request_Maintenance_Snapshot_0(rctx, inboundMarshaler, client, req, pathParams)
1673 ctx = runtime.NewServerMetadataContext(ctx, md)
1674 if err != nil {
1675 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1676 return
1677 }
1678
1679 forward_Maintenance_Snapshot_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
1680
1681 })
1682
1683 mux.Handle("POST", pattern_Maintenance_MoveLeader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1684 ctx, cancel := context.WithCancel(req.Context())
1685 defer cancel()
1686 if cn, ok := w.(http.CloseNotifier); ok {
1687 go func(done <-chan struct{}, closed <-chan bool) {
1688 select {
1689 case <-done:
1690 case <-closed:
1691 cancel()
1692 }
1693 }(ctx.Done(), cn.CloseNotify())
1694 }
1695 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1696 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1697 if err != nil {
1698 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1699 return
1700 }
1701 resp, md, err := request_Maintenance_MoveLeader_0(rctx, inboundMarshaler, client, req, pathParams)
1702 ctx = runtime.NewServerMetadataContext(ctx, md)
1703 if err != nil {
1704 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1705 return
1706 }
1707
1708 forward_Maintenance_MoveLeader_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1709
1710 })
1711
1712 return nil
1713}
1714
1715var (
1716 pattern_Maintenance_Alarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "alarm"}, ""))
1717
1718 pattern_Maintenance_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "status"}, ""))
1719
1720 pattern_Maintenance_Defragment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "defragment"}, ""))
1721
1722 pattern_Maintenance_Hash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "hash"}, ""))
1723
1724 pattern_Maintenance_HashKV_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "hash"}, ""))
1725
1726 pattern_Maintenance_Snapshot_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "snapshot"}, ""))
1727
1728 pattern_Maintenance_MoveLeader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "transfer-leadership"}, ""))
1729)
1730
1731var (
1732 forward_Maintenance_Alarm_0 = runtime.ForwardResponseMessage
1733
1734 forward_Maintenance_Status_0 = runtime.ForwardResponseMessage
1735
1736 forward_Maintenance_Defragment_0 = runtime.ForwardResponseMessage
1737
1738 forward_Maintenance_Hash_0 = runtime.ForwardResponseMessage
1739
1740 forward_Maintenance_HashKV_0 = runtime.ForwardResponseMessage
1741
1742 forward_Maintenance_Snapshot_0 = runtime.ForwardResponseStream
1743
1744 forward_Maintenance_MoveLeader_0 = runtime.ForwardResponseMessage
1745)
1746
1747// RegisterAuthHandlerFromEndpoint is same as RegisterAuthHandler but
1748// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
1749func RegisterAuthHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
1750 conn, err := grpc.Dial(endpoint, opts...)
1751 if err != nil {
1752 return err
1753 }
1754 defer func() {
1755 if err != nil {
1756 if cerr := conn.Close(); cerr != nil {
1757 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
1758 }
1759 return
1760 }
1761 go func() {
1762 <-ctx.Done()
1763 if cerr := conn.Close(); cerr != nil {
1764 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
1765 }
1766 }()
1767 }()
1768
1769 return RegisterAuthHandler(ctx, mux, conn)
1770}
1771
1772// RegisterAuthHandler registers the http handlers for service Auth to "mux".
1773// The handlers forward requests to the grpc endpoint over "conn".
1774func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
1775 return RegisterAuthHandlerClient(ctx, mux, etcdserverpb.NewAuthClient(conn))
1776}
1777
1778// RegisterAuthHandler registers the http handlers for service Auth to "mux".
1779// The handlers forward requests to the grpc endpoint over the given implementation of "AuthClient".
1780// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AuthClient"
1781// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
1782// "AuthClient" to call the correct interceptors.
1783func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.AuthClient) error {
1784
1785 mux.Handle("POST", pattern_Auth_AuthEnable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1786 ctx, cancel := context.WithCancel(req.Context())
1787 defer cancel()
1788 if cn, ok := w.(http.CloseNotifier); ok {
1789 go func(done <-chan struct{}, closed <-chan bool) {
1790 select {
1791 case <-done:
1792 case <-closed:
1793 cancel()
1794 }
1795 }(ctx.Done(), cn.CloseNotify())
1796 }
1797 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1798 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1799 if err != nil {
1800 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1801 return
1802 }
1803 resp, md, err := request_Auth_AuthEnable_0(rctx, inboundMarshaler, client, req, pathParams)
1804 ctx = runtime.NewServerMetadataContext(ctx, md)
1805 if err != nil {
1806 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1807 return
1808 }
1809
1810 forward_Auth_AuthEnable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1811
1812 })
1813
1814 mux.Handle("POST", pattern_Auth_AuthDisable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1815 ctx, cancel := context.WithCancel(req.Context())
1816 defer cancel()
1817 if cn, ok := w.(http.CloseNotifier); ok {
1818 go func(done <-chan struct{}, closed <-chan bool) {
1819 select {
1820 case <-done:
1821 case <-closed:
1822 cancel()
1823 }
1824 }(ctx.Done(), cn.CloseNotify())
1825 }
1826 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1827 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1828 if err != nil {
1829 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1830 return
1831 }
1832 resp, md, err := request_Auth_AuthDisable_0(rctx, inboundMarshaler, client, req, pathParams)
1833 ctx = runtime.NewServerMetadataContext(ctx, md)
1834 if err != nil {
1835 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1836 return
1837 }
1838
1839 forward_Auth_AuthDisable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1840
1841 })
1842
1843 mux.Handle("POST", pattern_Auth_Authenticate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1844 ctx, cancel := context.WithCancel(req.Context())
1845 defer cancel()
1846 if cn, ok := w.(http.CloseNotifier); ok {
1847 go func(done <-chan struct{}, closed <-chan bool) {
1848 select {
1849 case <-done:
1850 case <-closed:
1851 cancel()
1852 }
1853 }(ctx.Done(), cn.CloseNotify())
1854 }
1855 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1856 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1857 if err != nil {
1858 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1859 return
1860 }
1861 resp, md, err := request_Auth_Authenticate_0(rctx, inboundMarshaler, client, req, pathParams)
1862 ctx = runtime.NewServerMetadataContext(ctx, md)
1863 if err != nil {
1864 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1865 return
1866 }
1867
1868 forward_Auth_Authenticate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1869
1870 })
1871
1872 mux.Handle("POST", pattern_Auth_UserAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1873 ctx, cancel := context.WithCancel(req.Context())
1874 defer cancel()
1875 if cn, ok := w.(http.CloseNotifier); ok {
1876 go func(done <-chan struct{}, closed <-chan bool) {
1877 select {
1878 case <-done:
1879 case <-closed:
1880 cancel()
1881 }
1882 }(ctx.Done(), cn.CloseNotify())
1883 }
1884 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1885 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1886 if err != nil {
1887 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1888 return
1889 }
1890 resp, md, err := request_Auth_UserAdd_0(rctx, inboundMarshaler, client, req, pathParams)
1891 ctx = runtime.NewServerMetadataContext(ctx, md)
1892 if err != nil {
1893 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1894 return
1895 }
1896
1897 forward_Auth_UserAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1898
1899 })
1900
1901 mux.Handle("POST", pattern_Auth_UserGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1902 ctx, cancel := context.WithCancel(req.Context())
1903 defer cancel()
1904 if cn, ok := w.(http.CloseNotifier); ok {
1905 go func(done <-chan struct{}, closed <-chan bool) {
1906 select {
1907 case <-done:
1908 case <-closed:
1909 cancel()
1910 }
1911 }(ctx.Done(), cn.CloseNotify())
1912 }
1913 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1914 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1915 if err != nil {
1916 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1917 return
1918 }
1919 resp, md, err := request_Auth_UserGet_0(rctx, inboundMarshaler, client, req, pathParams)
1920 ctx = runtime.NewServerMetadataContext(ctx, md)
1921 if err != nil {
1922 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1923 return
1924 }
1925
1926 forward_Auth_UserGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1927
1928 })
1929
1930 mux.Handle("POST", pattern_Auth_UserList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1931 ctx, cancel := context.WithCancel(req.Context())
1932 defer cancel()
1933 if cn, ok := w.(http.CloseNotifier); ok {
1934 go func(done <-chan struct{}, closed <-chan bool) {
1935 select {
1936 case <-done:
1937 case <-closed:
1938 cancel()
1939 }
1940 }(ctx.Done(), cn.CloseNotify())
1941 }
1942 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1943 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1944 if err != nil {
1945 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1946 return
1947 }
1948 resp, md, err := request_Auth_UserList_0(rctx, inboundMarshaler, client, req, pathParams)
1949 ctx = runtime.NewServerMetadataContext(ctx, md)
1950 if err != nil {
1951 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1952 return
1953 }
1954
1955 forward_Auth_UserList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1956
1957 })
1958
1959 mux.Handle("POST", pattern_Auth_UserDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1960 ctx, cancel := context.WithCancel(req.Context())
1961 defer cancel()
1962 if cn, ok := w.(http.CloseNotifier); ok {
1963 go func(done <-chan struct{}, closed <-chan bool) {
1964 select {
1965 case <-done:
1966 case <-closed:
1967 cancel()
1968 }
1969 }(ctx.Done(), cn.CloseNotify())
1970 }
1971 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
1972 rctx, err := runtime.AnnotateContext(ctx, mux, req)
1973 if err != nil {
1974 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1975 return
1976 }
1977 resp, md, err := request_Auth_UserDelete_0(rctx, inboundMarshaler, client, req, pathParams)
1978 ctx = runtime.NewServerMetadataContext(ctx, md)
1979 if err != nil {
1980 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
1981 return
1982 }
1983
1984 forward_Auth_UserDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
1985
1986 })
1987
1988 mux.Handle("POST", pattern_Auth_UserChangePassword_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
1989 ctx, cancel := context.WithCancel(req.Context())
1990 defer cancel()
1991 if cn, ok := w.(http.CloseNotifier); ok {
1992 go func(done <-chan struct{}, closed <-chan bool) {
1993 select {
1994 case <-done:
1995 case <-closed:
1996 cancel()
1997 }
1998 }(ctx.Done(), cn.CloseNotify())
1999 }
2000 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2001 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2002 if err != nil {
2003 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2004 return
2005 }
2006 resp, md, err := request_Auth_UserChangePassword_0(rctx, inboundMarshaler, client, req, pathParams)
2007 ctx = runtime.NewServerMetadataContext(ctx, md)
2008 if err != nil {
2009 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2010 return
2011 }
2012
2013 forward_Auth_UserChangePassword_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2014
2015 })
2016
2017 mux.Handle("POST", pattern_Auth_UserGrantRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2018 ctx, cancel := context.WithCancel(req.Context())
2019 defer cancel()
2020 if cn, ok := w.(http.CloseNotifier); ok {
2021 go func(done <-chan struct{}, closed <-chan bool) {
2022 select {
2023 case <-done:
2024 case <-closed:
2025 cancel()
2026 }
2027 }(ctx.Done(), cn.CloseNotify())
2028 }
2029 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2030 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2031 if err != nil {
2032 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2033 return
2034 }
2035 resp, md, err := request_Auth_UserGrantRole_0(rctx, inboundMarshaler, client, req, pathParams)
2036 ctx = runtime.NewServerMetadataContext(ctx, md)
2037 if err != nil {
2038 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2039 return
2040 }
2041
2042 forward_Auth_UserGrantRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2043
2044 })
2045
2046 mux.Handle("POST", pattern_Auth_UserRevokeRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2047 ctx, cancel := context.WithCancel(req.Context())
2048 defer cancel()
2049 if cn, ok := w.(http.CloseNotifier); ok {
2050 go func(done <-chan struct{}, closed <-chan bool) {
2051 select {
2052 case <-done:
2053 case <-closed:
2054 cancel()
2055 }
2056 }(ctx.Done(), cn.CloseNotify())
2057 }
2058 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2059 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2060 if err != nil {
2061 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2062 return
2063 }
2064 resp, md, err := request_Auth_UserRevokeRole_0(rctx, inboundMarshaler, client, req, pathParams)
2065 ctx = runtime.NewServerMetadataContext(ctx, md)
2066 if err != nil {
2067 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2068 return
2069 }
2070
2071 forward_Auth_UserRevokeRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2072
2073 })
2074
2075 mux.Handle("POST", pattern_Auth_RoleAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2076 ctx, cancel := context.WithCancel(req.Context())
2077 defer cancel()
2078 if cn, ok := w.(http.CloseNotifier); ok {
2079 go func(done <-chan struct{}, closed <-chan bool) {
2080 select {
2081 case <-done:
2082 case <-closed:
2083 cancel()
2084 }
2085 }(ctx.Done(), cn.CloseNotify())
2086 }
2087 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2088 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2089 if err != nil {
2090 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2091 return
2092 }
2093 resp, md, err := request_Auth_RoleAdd_0(rctx, inboundMarshaler, client, req, pathParams)
2094 ctx = runtime.NewServerMetadataContext(ctx, md)
2095 if err != nil {
2096 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2097 return
2098 }
2099
2100 forward_Auth_RoleAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2101
2102 })
2103
2104 mux.Handle("POST", pattern_Auth_RoleGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2105 ctx, cancel := context.WithCancel(req.Context())
2106 defer cancel()
2107 if cn, ok := w.(http.CloseNotifier); ok {
2108 go func(done <-chan struct{}, closed <-chan bool) {
2109 select {
2110 case <-done:
2111 case <-closed:
2112 cancel()
2113 }
2114 }(ctx.Done(), cn.CloseNotify())
2115 }
2116 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2117 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2118 if err != nil {
2119 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2120 return
2121 }
2122 resp, md, err := request_Auth_RoleGet_0(rctx, inboundMarshaler, client, req, pathParams)
2123 ctx = runtime.NewServerMetadataContext(ctx, md)
2124 if err != nil {
2125 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2126 return
2127 }
2128
2129 forward_Auth_RoleGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2130
2131 })
2132
2133 mux.Handle("POST", pattern_Auth_RoleList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2134 ctx, cancel := context.WithCancel(req.Context())
2135 defer cancel()
2136 if cn, ok := w.(http.CloseNotifier); ok {
2137 go func(done <-chan struct{}, closed <-chan bool) {
2138 select {
2139 case <-done:
2140 case <-closed:
2141 cancel()
2142 }
2143 }(ctx.Done(), cn.CloseNotify())
2144 }
2145 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2146 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2147 if err != nil {
2148 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2149 return
2150 }
2151 resp, md, err := request_Auth_RoleList_0(rctx, inboundMarshaler, client, req, pathParams)
2152 ctx = runtime.NewServerMetadataContext(ctx, md)
2153 if err != nil {
2154 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2155 return
2156 }
2157
2158 forward_Auth_RoleList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2159
2160 })
2161
2162 mux.Handle("POST", pattern_Auth_RoleDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2163 ctx, cancel := context.WithCancel(req.Context())
2164 defer cancel()
2165 if cn, ok := w.(http.CloseNotifier); ok {
2166 go func(done <-chan struct{}, closed <-chan bool) {
2167 select {
2168 case <-done:
2169 case <-closed:
2170 cancel()
2171 }
2172 }(ctx.Done(), cn.CloseNotify())
2173 }
2174 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2175 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2176 if err != nil {
2177 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2178 return
2179 }
2180 resp, md, err := request_Auth_RoleDelete_0(rctx, inboundMarshaler, client, req, pathParams)
2181 ctx = runtime.NewServerMetadataContext(ctx, md)
2182 if err != nil {
2183 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2184 return
2185 }
2186
2187 forward_Auth_RoleDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2188
2189 })
2190
2191 mux.Handle("POST", pattern_Auth_RoleGrantPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2192 ctx, cancel := context.WithCancel(req.Context())
2193 defer cancel()
2194 if cn, ok := w.(http.CloseNotifier); ok {
2195 go func(done <-chan struct{}, closed <-chan bool) {
2196 select {
2197 case <-done:
2198 case <-closed:
2199 cancel()
2200 }
2201 }(ctx.Done(), cn.CloseNotify())
2202 }
2203 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2204 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2205 if err != nil {
2206 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2207 return
2208 }
2209 resp, md, err := request_Auth_RoleGrantPermission_0(rctx, inboundMarshaler, client, req, pathParams)
2210 ctx = runtime.NewServerMetadataContext(ctx, md)
2211 if err != nil {
2212 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2213 return
2214 }
2215
2216 forward_Auth_RoleGrantPermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2217
2218 })
2219
2220 mux.Handle("POST", pattern_Auth_RoleRevokePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
2221 ctx, cancel := context.WithCancel(req.Context())
2222 defer cancel()
2223 if cn, ok := w.(http.CloseNotifier); ok {
2224 go func(done <-chan struct{}, closed <-chan bool) {
2225 select {
2226 case <-done:
2227 case <-closed:
2228 cancel()
2229 }
2230 }(ctx.Done(), cn.CloseNotify())
2231 }
2232 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
2233 rctx, err := runtime.AnnotateContext(ctx, mux, req)
2234 if err != nil {
2235 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2236 return
2237 }
2238 resp, md, err := request_Auth_RoleRevokePermission_0(rctx, inboundMarshaler, client, req, pathParams)
2239 ctx = runtime.NewServerMetadataContext(ctx, md)
2240 if err != nil {
2241 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
2242 return
2243 }
2244
2245 forward_Auth_RoleRevokePermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
2246
2247 })
2248
2249 return nil
2250}
2251
2252var (
2253 pattern_Auth_AuthEnable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "auth", "enable"}, ""))
2254
2255 pattern_Auth_AuthDisable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "auth", "disable"}, ""))
2256
2257 pattern_Auth_Authenticate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "auth", "authenticate"}, ""))
2258
2259 pattern_Auth_UserAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "add"}, ""))
2260
2261 pattern_Auth_UserGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "get"}, ""))
2262
2263 pattern_Auth_UserList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "list"}, ""))
2264
2265 pattern_Auth_UserDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "delete"}, ""))
2266
2267 pattern_Auth_UserChangePassword_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "changepw"}, ""))
2268
2269 pattern_Auth_UserGrantRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "grant"}, ""))
2270
2271 pattern_Auth_UserRevokeRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "revoke"}, ""))
2272
2273 pattern_Auth_RoleAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "add"}, ""))
2274
2275 pattern_Auth_RoleGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "get"}, ""))
2276
2277 pattern_Auth_RoleList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "list"}, ""))
2278
2279 pattern_Auth_RoleDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "delete"}, ""))
2280
2281 pattern_Auth_RoleGrantPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "grant"}, ""))
2282
2283 pattern_Auth_RoleRevokePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "revoke"}, ""))
2284)
2285
2286var (
2287 forward_Auth_AuthEnable_0 = runtime.ForwardResponseMessage
2288
2289 forward_Auth_AuthDisable_0 = runtime.ForwardResponseMessage
2290
2291 forward_Auth_Authenticate_0 = runtime.ForwardResponseMessage
2292
2293 forward_Auth_UserAdd_0 = runtime.ForwardResponseMessage
2294
2295 forward_Auth_UserGet_0 = runtime.ForwardResponseMessage
2296
2297 forward_Auth_UserList_0 = runtime.ForwardResponseMessage
2298
2299 forward_Auth_UserDelete_0 = runtime.ForwardResponseMessage
2300
2301 forward_Auth_UserChangePassword_0 = runtime.ForwardResponseMessage
2302
2303 forward_Auth_UserGrantRole_0 = runtime.ForwardResponseMessage
2304
2305 forward_Auth_UserRevokeRole_0 = runtime.ForwardResponseMessage
2306
2307 forward_Auth_RoleAdd_0 = runtime.ForwardResponseMessage
2308
2309 forward_Auth_RoleGet_0 = runtime.ForwardResponseMessage
2310
2311 forward_Auth_RoleList_0 = runtime.ForwardResponseMessage
2312
2313 forward_Auth_RoleDelete_0 = runtime.ForwardResponseMessage
2314
2315 forward_Auth_RoleGrantPermission_0 = runtime.ForwardResponseMessage
2316
2317 forward_Auth_RoleRevokePermission_0 = runtime.ForwardResponseMessage
2318)