1// 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)
2319