Source file src/go.etcd.io/etcd/api/v3/etcdserverpb/gw/rpc.pb.gw.go

Documentation: go.etcd.io/etcd/api/v3/etcdserverpb/gw

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: api/etcdserverpb/rpc.proto
     3  
     4  /*
     5  Package etcdserverpb is a reverse proxy.
     6  
     7  It translates gRPC into RESTful JSON APIs.
     8  */
     9  package gw
    10  
    11  import (
    12  	"context"
    13  	"go.etcd.io/etcd/api/v3/etcdserverpb"
    14  	"io"
    15  	"net/http"
    16  
    17  	"github.com/golang/protobuf/descriptor"
    18  	"github.com/golang/protobuf/proto"
    19  	"github.com/grpc-ecosystem/grpc-gateway/runtime"
    20  	"github.com/grpc-ecosystem/grpc-gateway/utilities"
    21  	"google.golang.org/grpc"
    22  	"google.golang.org/grpc/codes"
    23  	"google.golang.org/grpc/grpclog"
    24  	"google.golang.org/grpc/status"
    25  )
    26  
    27  // Suppress "imported and not used" errors
    28  var _ codes.Code
    29  var _ io.Reader
    30  var _ status.Status
    31  var _ = runtime.String
    32  var _ = utilities.NewDoubleArray
    33  var _ = descriptor.ForMessage
    34  
    35  func 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) {
    36  	var protoReq etcdserverpb.RangeRequest
    37  	var metadata runtime.ServerMetadata
    38  
    39  	newReader, berr := utilities.IOReaderFactory(req.Body)
    40  	if berr != nil {
    41  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    42  	}
    43  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    44  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    45  	}
    46  
    47  	msg, err := client.Range(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    48  	return msg, metadata, err
    49  
    50  }
    51  
    52  func local_request_KV_Range_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.KVServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    53  	var protoReq etcdserverpb.RangeRequest
    54  	var metadata runtime.ServerMetadata
    55  
    56  	newReader, berr := utilities.IOReaderFactory(req.Body)
    57  	if berr != nil {
    58  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    59  	}
    60  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    61  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    62  	}
    63  
    64  	msg, err := server.Range(ctx, &protoReq)
    65  	return msg, metadata, err
    66  
    67  }
    68  
    69  func 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) {
    70  	var protoReq etcdserverpb.PutRequest
    71  	var metadata runtime.ServerMetadata
    72  
    73  	newReader, berr := utilities.IOReaderFactory(req.Body)
    74  	if berr != nil {
    75  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    76  	}
    77  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    78  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    79  	}
    80  
    81  	msg, err := client.Put(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    82  	return msg, metadata, err
    83  
    84  }
    85  
    86  func local_request_KV_Put_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.KVServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    87  	var protoReq etcdserverpb.PutRequest
    88  	var metadata runtime.ServerMetadata
    89  
    90  	newReader, berr := utilities.IOReaderFactory(req.Body)
    91  	if berr != nil {
    92  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    93  	}
    94  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    95  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    96  	}
    97  
    98  	msg, err := server.Put(ctx, &protoReq)
    99  	return msg, metadata, err
   100  
   101  }
   102  
   103  func 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) {
   104  	var protoReq etcdserverpb.DeleteRangeRequest
   105  	var metadata runtime.ServerMetadata
   106  
   107  	newReader, berr := utilities.IOReaderFactory(req.Body)
   108  	if berr != nil {
   109  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   110  	}
   111  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   112  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   113  	}
   114  
   115  	msg, err := client.DeleteRange(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   116  	return msg, metadata, err
   117  
   118  }
   119  
   120  func local_request_KV_DeleteRange_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.KVServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   121  	var protoReq etcdserverpb.DeleteRangeRequest
   122  	var metadata runtime.ServerMetadata
   123  
   124  	newReader, berr := utilities.IOReaderFactory(req.Body)
   125  	if berr != nil {
   126  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   127  	}
   128  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   129  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   130  	}
   131  
   132  	msg, err := server.DeleteRange(ctx, &protoReq)
   133  	return msg, metadata, err
   134  
   135  }
   136  
   137  func 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) {
   138  	var protoReq etcdserverpb.TxnRequest
   139  	var metadata runtime.ServerMetadata
   140  
   141  	newReader, berr := utilities.IOReaderFactory(req.Body)
   142  	if berr != nil {
   143  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   144  	}
   145  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   146  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   147  	}
   148  
   149  	msg, err := client.Txn(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   150  	return msg, metadata, err
   151  
   152  }
   153  
   154  func local_request_KV_Txn_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.KVServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   155  	var protoReq etcdserverpb.TxnRequest
   156  	var metadata runtime.ServerMetadata
   157  
   158  	newReader, berr := utilities.IOReaderFactory(req.Body)
   159  	if berr != nil {
   160  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   161  	}
   162  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   163  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   164  	}
   165  
   166  	msg, err := server.Txn(ctx, &protoReq)
   167  	return msg, metadata, err
   168  
   169  }
   170  
   171  func 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) {
   172  	var protoReq etcdserverpb.CompactionRequest
   173  	var metadata runtime.ServerMetadata
   174  
   175  	newReader, berr := utilities.IOReaderFactory(req.Body)
   176  	if berr != nil {
   177  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   178  	}
   179  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   180  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   181  	}
   182  
   183  	msg, err := client.Compact(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   184  	return msg, metadata, err
   185  
   186  }
   187  
   188  func local_request_KV_Compact_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.KVServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   189  	var protoReq etcdserverpb.CompactionRequest
   190  	var metadata runtime.ServerMetadata
   191  
   192  	newReader, berr := utilities.IOReaderFactory(req.Body)
   193  	if berr != nil {
   194  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   195  	}
   196  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   197  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   198  	}
   199  
   200  	msg, err := server.Compact(ctx, &protoReq)
   201  	return msg, metadata, err
   202  
   203  }
   204  
   205  func 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) {
   206  	var metadata runtime.ServerMetadata
   207  	stream, err := client.Watch(ctx)
   208  	if err != nil {
   209  		grpclog.Infof("Failed to start streaming: %v", err)
   210  		return nil, metadata, err
   211  	}
   212  	dec := marshaler.NewDecoder(req.Body)
   213  	handleSend := func() error {
   214  		var protoReq etcdserverpb.WatchRequest
   215  		err := dec.Decode(&protoReq)
   216  		if err == io.EOF {
   217  			return err
   218  		}
   219  		if err != nil {
   220  			grpclog.Infof("Failed to decode request: %v", err)
   221  			return err
   222  		}
   223  		if err := stream.Send(&protoReq); err != nil {
   224  			grpclog.Infof("Failed to send request: %v", err)
   225  			return err
   226  		}
   227  		return nil
   228  	}
   229  	if err := handleSend(); err != nil {
   230  		if cerr := stream.CloseSend(); cerr != nil {
   231  			grpclog.Infof("Failed to terminate client stream: %v", cerr)
   232  		}
   233  		if err == io.EOF {
   234  			return stream, metadata, nil
   235  		}
   236  		return nil, metadata, err
   237  	}
   238  	go func() {
   239  		for {
   240  			if err := handleSend(); err != nil {
   241  				break
   242  			}
   243  		}
   244  		if err := stream.CloseSend(); err != nil {
   245  			grpclog.Infof("Failed to terminate client stream: %v", err)
   246  		}
   247  	}()
   248  	header, err := stream.Header()
   249  	if err != nil {
   250  		grpclog.Infof("Failed to get header from client: %v", err)
   251  		return nil, metadata, err
   252  	}
   253  	metadata.HeaderMD = header
   254  	return stream, metadata, nil
   255  }
   256  
   257  func 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) {
   258  	var protoReq etcdserverpb.LeaseGrantRequest
   259  	var metadata runtime.ServerMetadata
   260  
   261  	newReader, berr := utilities.IOReaderFactory(req.Body)
   262  	if berr != nil {
   263  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   264  	}
   265  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   266  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   267  	}
   268  
   269  	msg, err := client.LeaseGrant(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   270  	return msg, metadata, err
   271  
   272  }
   273  
   274  func local_request_Lease_LeaseGrant_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.LeaseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   275  	var protoReq etcdserverpb.LeaseGrantRequest
   276  	var metadata runtime.ServerMetadata
   277  
   278  	newReader, berr := utilities.IOReaderFactory(req.Body)
   279  	if berr != nil {
   280  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   281  	}
   282  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   283  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   284  	}
   285  
   286  	msg, err := server.LeaseGrant(ctx, &protoReq)
   287  	return msg, metadata, err
   288  
   289  }
   290  
   291  func 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) {
   292  	var protoReq etcdserverpb.LeaseRevokeRequest
   293  	var metadata runtime.ServerMetadata
   294  
   295  	newReader, berr := utilities.IOReaderFactory(req.Body)
   296  	if berr != nil {
   297  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   298  	}
   299  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   300  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   301  	}
   302  
   303  	msg, err := client.LeaseRevoke(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   304  	return msg, metadata, err
   305  
   306  }
   307  
   308  func local_request_Lease_LeaseRevoke_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.LeaseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   309  	var protoReq etcdserverpb.LeaseRevokeRequest
   310  	var metadata runtime.ServerMetadata
   311  
   312  	newReader, berr := utilities.IOReaderFactory(req.Body)
   313  	if berr != nil {
   314  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   315  	}
   316  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   317  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   318  	}
   319  
   320  	msg, err := server.LeaseRevoke(ctx, &protoReq)
   321  	return msg, metadata, err
   322  
   323  }
   324  
   325  func 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) {
   326  	var protoReq etcdserverpb.LeaseRevokeRequest
   327  	var metadata runtime.ServerMetadata
   328  
   329  	newReader, berr := utilities.IOReaderFactory(req.Body)
   330  	if berr != nil {
   331  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   332  	}
   333  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   334  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   335  	}
   336  
   337  	msg, err := client.LeaseRevoke(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   338  	return msg, metadata, err
   339  
   340  }
   341  
   342  func local_request_Lease_LeaseRevoke_1(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.LeaseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   343  	var protoReq etcdserverpb.LeaseRevokeRequest
   344  	var metadata runtime.ServerMetadata
   345  
   346  	newReader, berr := utilities.IOReaderFactory(req.Body)
   347  	if berr != nil {
   348  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   349  	}
   350  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   351  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   352  	}
   353  
   354  	msg, err := server.LeaseRevoke(ctx, &protoReq)
   355  	return msg, metadata, err
   356  
   357  }
   358  
   359  func 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) {
   360  	var metadata runtime.ServerMetadata
   361  	stream, err := client.LeaseKeepAlive(ctx)
   362  	if err != nil {
   363  		grpclog.Infof("Failed to start streaming: %v", err)
   364  		return nil, metadata, err
   365  	}
   366  	dec := marshaler.NewDecoder(req.Body)
   367  	handleSend := func() error {
   368  		var protoReq etcdserverpb.LeaseKeepAliveRequest
   369  		err := dec.Decode(&protoReq)
   370  		if err == io.EOF {
   371  			return err
   372  		}
   373  		if err != nil {
   374  			grpclog.Infof("Failed to decode request: %v", err)
   375  			return err
   376  		}
   377  		if err := stream.Send(&protoReq); err != nil {
   378  			grpclog.Infof("Failed to send request: %v", err)
   379  			return err
   380  		}
   381  		return nil
   382  	}
   383  	if err := handleSend(); err != nil {
   384  		if cerr := stream.CloseSend(); cerr != nil {
   385  			grpclog.Infof("Failed to terminate client stream: %v", cerr)
   386  		}
   387  		if err == io.EOF {
   388  			return stream, metadata, nil
   389  		}
   390  		return nil, metadata, err
   391  	}
   392  	go func() {
   393  		for {
   394  			if err := handleSend(); err != nil {
   395  				break
   396  			}
   397  		}
   398  		if err := stream.CloseSend(); err != nil {
   399  			grpclog.Infof("Failed to terminate client stream: %v", err)
   400  		}
   401  	}()
   402  	header, err := stream.Header()
   403  	if err != nil {
   404  		grpclog.Infof("Failed to get header from client: %v", err)
   405  		return nil, metadata, err
   406  	}
   407  	metadata.HeaderMD = header
   408  	return stream, metadata, nil
   409  }
   410  
   411  func 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) {
   412  	var protoReq etcdserverpb.LeaseTimeToLiveRequest
   413  	var metadata runtime.ServerMetadata
   414  
   415  	newReader, berr := utilities.IOReaderFactory(req.Body)
   416  	if berr != nil {
   417  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   418  	}
   419  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   420  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   421  	}
   422  
   423  	msg, err := client.LeaseTimeToLive(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   424  	return msg, metadata, err
   425  
   426  }
   427  
   428  func local_request_Lease_LeaseTimeToLive_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.LeaseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   429  	var protoReq etcdserverpb.LeaseTimeToLiveRequest
   430  	var metadata runtime.ServerMetadata
   431  
   432  	newReader, berr := utilities.IOReaderFactory(req.Body)
   433  	if berr != nil {
   434  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   435  	}
   436  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   437  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   438  	}
   439  
   440  	msg, err := server.LeaseTimeToLive(ctx, &protoReq)
   441  	return msg, metadata, err
   442  
   443  }
   444  
   445  func 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) {
   446  	var protoReq etcdserverpb.LeaseTimeToLiveRequest
   447  	var metadata runtime.ServerMetadata
   448  
   449  	newReader, berr := utilities.IOReaderFactory(req.Body)
   450  	if berr != nil {
   451  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   452  	}
   453  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   454  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   455  	}
   456  
   457  	msg, err := client.LeaseTimeToLive(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   458  	return msg, metadata, err
   459  
   460  }
   461  
   462  func local_request_Lease_LeaseTimeToLive_1(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.LeaseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   463  	var protoReq etcdserverpb.LeaseTimeToLiveRequest
   464  	var metadata runtime.ServerMetadata
   465  
   466  	newReader, berr := utilities.IOReaderFactory(req.Body)
   467  	if berr != nil {
   468  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   469  	}
   470  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   471  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   472  	}
   473  
   474  	msg, err := server.LeaseTimeToLive(ctx, &protoReq)
   475  	return msg, metadata, err
   476  
   477  }
   478  
   479  func 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) {
   480  	var protoReq etcdserverpb.LeaseLeasesRequest
   481  	var metadata runtime.ServerMetadata
   482  
   483  	newReader, berr := utilities.IOReaderFactory(req.Body)
   484  	if berr != nil {
   485  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   486  	}
   487  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   488  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   489  	}
   490  
   491  	msg, err := client.LeaseLeases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   492  	return msg, metadata, err
   493  
   494  }
   495  
   496  func local_request_Lease_LeaseLeases_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.LeaseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   497  	var protoReq etcdserverpb.LeaseLeasesRequest
   498  	var metadata runtime.ServerMetadata
   499  
   500  	newReader, berr := utilities.IOReaderFactory(req.Body)
   501  	if berr != nil {
   502  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   503  	}
   504  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   505  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   506  	}
   507  
   508  	msg, err := server.LeaseLeases(ctx, &protoReq)
   509  	return msg, metadata, err
   510  
   511  }
   512  
   513  func 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) {
   514  	var protoReq etcdserverpb.LeaseLeasesRequest
   515  	var metadata runtime.ServerMetadata
   516  
   517  	newReader, berr := utilities.IOReaderFactory(req.Body)
   518  	if berr != nil {
   519  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   520  	}
   521  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   522  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   523  	}
   524  
   525  	msg, err := client.LeaseLeases(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   526  	return msg, metadata, err
   527  
   528  }
   529  
   530  func local_request_Lease_LeaseLeases_1(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.LeaseServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   531  	var protoReq etcdserverpb.LeaseLeasesRequest
   532  	var metadata runtime.ServerMetadata
   533  
   534  	newReader, berr := utilities.IOReaderFactory(req.Body)
   535  	if berr != nil {
   536  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   537  	}
   538  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   539  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   540  	}
   541  
   542  	msg, err := server.LeaseLeases(ctx, &protoReq)
   543  	return msg, metadata, err
   544  
   545  }
   546  
   547  func 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) {
   548  	var protoReq etcdserverpb.MemberAddRequest
   549  	var metadata runtime.ServerMetadata
   550  
   551  	newReader, berr := utilities.IOReaderFactory(req.Body)
   552  	if berr != nil {
   553  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   554  	}
   555  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   556  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   557  	}
   558  
   559  	msg, err := client.MemberAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   560  	return msg, metadata, err
   561  
   562  }
   563  
   564  func local_request_Cluster_MemberAdd_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.ClusterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   565  	var protoReq etcdserverpb.MemberAddRequest
   566  	var metadata runtime.ServerMetadata
   567  
   568  	newReader, berr := utilities.IOReaderFactory(req.Body)
   569  	if berr != nil {
   570  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   571  	}
   572  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   573  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   574  	}
   575  
   576  	msg, err := server.MemberAdd(ctx, &protoReq)
   577  	return msg, metadata, err
   578  
   579  }
   580  
   581  func 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) {
   582  	var protoReq etcdserverpb.MemberRemoveRequest
   583  	var metadata runtime.ServerMetadata
   584  
   585  	newReader, berr := utilities.IOReaderFactory(req.Body)
   586  	if berr != nil {
   587  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   588  	}
   589  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   590  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   591  	}
   592  
   593  	msg, err := client.MemberRemove(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   594  	return msg, metadata, err
   595  
   596  }
   597  
   598  func local_request_Cluster_MemberRemove_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.ClusterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   599  	var protoReq etcdserverpb.MemberRemoveRequest
   600  	var metadata runtime.ServerMetadata
   601  
   602  	newReader, berr := utilities.IOReaderFactory(req.Body)
   603  	if berr != nil {
   604  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   605  	}
   606  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   607  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   608  	}
   609  
   610  	msg, err := server.MemberRemove(ctx, &protoReq)
   611  	return msg, metadata, err
   612  
   613  }
   614  
   615  func 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) {
   616  	var protoReq etcdserverpb.MemberUpdateRequest
   617  	var metadata runtime.ServerMetadata
   618  
   619  	newReader, berr := utilities.IOReaderFactory(req.Body)
   620  	if berr != nil {
   621  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   622  	}
   623  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   624  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   625  	}
   626  
   627  	msg, err := client.MemberUpdate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   628  	return msg, metadata, err
   629  
   630  }
   631  
   632  func local_request_Cluster_MemberUpdate_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.ClusterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   633  	var protoReq etcdserverpb.MemberUpdateRequest
   634  	var metadata runtime.ServerMetadata
   635  
   636  	newReader, berr := utilities.IOReaderFactory(req.Body)
   637  	if berr != nil {
   638  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   639  	}
   640  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   641  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   642  	}
   643  
   644  	msg, err := server.MemberUpdate(ctx, &protoReq)
   645  	return msg, metadata, err
   646  
   647  }
   648  
   649  func 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) {
   650  	var protoReq etcdserverpb.MemberListRequest
   651  	var metadata runtime.ServerMetadata
   652  
   653  	newReader, berr := utilities.IOReaderFactory(req.Body)
   654  	if berr != nil {
   655  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   656  	}
   657  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   658  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   659  	}
   660  
   661  	msg, err := client.MemberList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   662  	return msg, metadata, err
   663  
   664  }
   665  
   666  func local_request_Cluster_MemberList_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.ClusterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   667  	var protoReq etcdserverpb.MemberListRequest
   668  	var metadata runtime.ServerMetadata
   669  
   670  	newReader, berr := utilities.IOReaderFactory(req.Body)
   671  	if berr != nil {
   672  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   673  	}
   674  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   675  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   676  	}
   677  
   678  	msg, err := server.MemberList(ctx, &protoReq)
   679  	return msg, metadata, err
   680  
   681  }
   682  
   683  func 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) {
   684  	var protoReq etcdserverpb.MemberPromoteRequest
   685  	var metadata runtime.ServerMetadata
   686  
   687  	newReader, berr := utilities.IOReaderFactory(req.Body)
   688  	if berr != nil {
   689  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   690  	}
   691  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   692  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   693  	}
   694  
   695  	msg, err := client.MemberPromote(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   696  	return msg, metadata, err
   697  
   698  }
   699  
   700  func local_request_Cluster_MemberPromote_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.ClusterServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   701  	var protoReq etcdserverpb.MemberPromoteRequest
   702  	var metadata runtime.ServerMetadata
   703  
   704  	newReader, berr := utilities.IOReaderFactory(req.Body)
   705  	if berr != nil {
   706  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   707  	}
   708  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   709  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   710  	}
   711  
   712  	msg, err := server.MemberPromote(ctx, &protoReq)
   713  	return msg, metadata, err
   714  
   715  }
   716  
   717  func 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) {
   718  	var protoReq etcdserverpb.AlarmRequest
   719  	var metadata runtime.ServerMetadata
   720  
   721  	newReader, berr := utilities.IOReaderFactory(req.Body)
   722  	if berr != nil {
   723  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   724  	}
   725  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   726  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   727  	}
   728  
   729  	msg, err := client.Alarm(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   730  	return msg, metadata, err
   731  
   732  }
   733  
   734  func local_request_Maintenance_Alarm_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.MaintenanceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   735  	var protoReq etcdserverpb.AlarmRequest
   736  	var metadata runtime.ServerMetadata
   737  
   738  	newReader, berr := utilities.IOReaderFactory(req.Body)
   739  	if berr != nil {
   740  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   741  	}
   742  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   743  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   744  	}
   745  
   746  	msg, err := server.Alarm(ctx, &protoReq)
   747  	return msg, metadata, err
   748  
   749  }
   750  
   751  func 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) {
   752  	var protoReq etcdserverpb.StatusRequest
   753  	var metadata runtime.ServerMetadata
   754  
   755  	newReader, berr := utilities.IOReaderFactory(req.Body)
   756  	if berr != nil {
   757  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   758  	}
   759  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   760  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   761  	}
   762  
   763  	msg, err := client.Status(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   764  	return msg, metadata, err
   765  
   766  }
   767  
   768  func local_request_Maintenance_Status_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.MaintenanceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   769  	var protoReq etcdserverpb.StatusRequest
   770  	var metadata runtime.ServerMetadata
   771  
   772  	newReader, berr := utilities.IOReaderFactory(req.Body)
   773  	if berr != nil {
   774  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   775  	}
   776  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   777  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   778  	}
   779  
   780  	msg, err := server.Status(ctx, &protoReq)
   781  	return msg, metadata, err
   782  
   783  }
   784  
   785  func 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) {
   786  	var protoReq etcdserverpb.DefragmentRequest
   787  	var metadata runtime.ServerMetadata
   788  
   789  	newReader, berr := utilities.IOReaderFactory(req.Body)
   790  	if berr != nil {
   791  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   792  	}
   793  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   794  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   795  	}
   796  
   797  	msg, err := client.Defragment(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   798  	return msg, metadata, err
   799  
   800  }
   801  
   802  func local_request_Maintenance_Defragment_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.MaintenanceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   803  	var protoReq etcdserverpb.DefragmentRequest
   804  	var metadata runtime.ServerMetadata
   805  
   806  	newReader, berr := utilities.IOReaderFactory(req.Body)
   807  	if berr != nil {
   808  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   809  	}
   810  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   811  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   812  	}
   813  
   814  	msg, err := server.Defragment(ctx, &protoReq)
   815  	return msg, metadata, err
   816  
   817  }
   818  
   819  func 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) {
   820  	var protoReq etcdserverpb.HashRequest
   821  	var metadata runtime.ServerMetadata
   822  
   823  	newReader, berr := utilities.IOReaderFactory(req.Body)
   824  	if berr != nil {
   825  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   826  	}
   827  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   828  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   829  	}
   830  
   831  	msg, err := client.Hash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   832  	return msg, metadata, err
   833  
   834  }
   835  
   836  func local_request_Maintenance_Hash_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.MaintenanceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   837  	var protoReq etcdserverpb.HashRequest
   838  	var metadata runtime.ServerMetadata
   839  
   840  	newReader, berr := utilities.IOReaderFactory(req.Body)
   841  	if berr != nil {
   842  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   843  	}
   844  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   845  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   846  	}
   847  
   848  	msg, err := server.Hash(ctx, &protoReq)
   849  	return msg, metadata, err
   850  
   851  }
   852  
   853  func 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) {
   854  	var protoReq etcdserverpb.HashKVRequest
   855  	var metadata runtime.ServerMetadata
   856  
   857  	newReader, berr := utilities.IOReaderFactory(req.Body)
   858  	if berr != nil {
   859  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   860  	}
   861  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   862  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   863  	}
   864  
   865  	msg, err := client.HashKV(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   866  	return msg, metadata, err
   867  
   868  }
   869  
   870  func local_request_Maintenance_HashKV_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.MaintenanceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   871  	var protoReq etcdserverpb.HashKVRequest
   872  	var metadata runtime.ServerMetadata
   873  
   874  	newReader, berr := utilities.IOReaderFactory(req.Body)
   875  	if berr != nil {
   876  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   877  	}
   878  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   879  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   880  	}
   881  
   882  	msg, err := server.HashKV(ctx, &protoReq)
   883  	return msg, metadata, err
   884  
   885  }
   886  
   887  func 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) {
   888  	var protoReq etcdserverpb.SnapshotRequest
   889  	var metadata runtime.ServerMetadata
   890  
   891  	newReader, berr := utilities.IOReaderFactory(req.Body)
   892  	if berr != nil {
   893  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   894  	}
   895  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   896  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   897  	}
   898  
   899  	stream, err := client.Snapshot(ctx, &protoReq)
   900  	if err != nil {
   901  		return nil, metadata, err
   902  	}
   903  	header, err := stream.Header()
   904  	if err != nil {
   905  		return nil, metadata, err
   906  	}
   907  	metadata.HeaderMD = header
   908  	return stream, metadata, nil
   909  
   910  }
   911  
   912  func 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) {
   913  	var protoReq etcdserverpb.MoveLeaderRequest
   914  	var metadata runtime.ServerMetadata
   915  
   916  	newReader, berr := utilities.IOReaderFactory(req.Body)
   917  	if berr != nil {
   918  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   919  	}
   920  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   921  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   922  	}
   923  
   924  	msg, err := client.MoveLeader(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   925  	return msg, metadata, err
   926  
   927  }
   928  
   929  func local_request_Maintenance_MoveLeader_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.MaintenanceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   930  	var protoReq etcdserverpb.MoveLeaderRequest
   931  	var metadata runtime.ServerMetadata
   932  
   933  	newReader, berr := utilities.IOReaderFactory(req.Body)
   934  	if berr != nil {
   935  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   936  	}
   937  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   938  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   939  	}
   940  
   941  	msg, err := server.MoveLeader(ctx, &protoReq)
   942  	return msg, metadata, err
   943  
   944  }
   945  
   946  func request_Maintenance_Downgrade_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.MaintenanceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   947  	var protoReq etcdserverpb.DowngradeRequest
   948  	var metadata runtime.ServerMetadata
   949  
   950  	newReader, berr := utilities.IOReaderFactory(req.Body)
   951  	if berr != nil {
   952  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   953  	}
   954  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   955  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   956  	}
   957  
   958  	msg, err := client.Downgrade(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   959  	return msg, metadata, err
   960  
   961  }
   962  
   963  func local_request_Maintenance_Downgrade_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.MaintenanceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   964  	var protoReq etcdserverpb.DowngradeRequest
   965  	var metadata runtime.ServerMetadata
   966  
   967  	newReader, berr := utilities.IOReaderFactory(req.Body)
   968  	if berr != nil {
   969  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   970  	}
   971  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   972  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   973  	}
   974  
   975  	msg, err := server.Downgrade(ctx, &protoReq)
   976  	return msg, metadata, err
   977  
   978  }
   979  
   980  func 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) {
   981  	var protoReq etcdserverpb.AuthEnableRequest
   982  	var metadata runtime.ServerMetadata
   983  
   984  	newReader, berr := utilities.IOReaderFactory(req.Body)
   985  	if berr != nil {
   986  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   987  	}
   988  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   989  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   990  	}
   991  
   992  	msg, err := client.AuthEnable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   993  	return msg, metadata, err
   994  
   995  }
   996  
   997  func local_request_Auth_AuthEnable_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   998  	var protoReq etcdserverpb.AuthEnableRequest
   999  	var metadata runtime.ServerMetadata
  1000  
  1001  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1002  	if berr != nil {
  1003  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1004  	}
  1005  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1006  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1007  	}
  1008  
  1009  	msg, err := server.AuthEnable(ctx, &protoReq)
  1010  	return msg, metadata, err
  1011  
  1012  }
  1013  
  1014  func 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) {
  1015  	var protoReq etcdserverpb.AuthDisableRequest
  1016  	var metadata runtime.ServerMetadata
  1017  
  1018  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1019  	if berr != nil {
  1020  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1021  	}
  1022  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1023  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1024  	}
  1025  
  1026  	msg, err := client.AuthDisable(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1027  	return msg, metadata, err
  1028  
  1029  }
  1030  
  1031  func local_request_Auth_AuthDisable_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1032  	var protoReq etcdserverpb.AuthDisableRequest
  1033  	var metadata runtime.ServerMetadata
  1034  
  1035  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1036  	if berr != nil {
  1037  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1038  	}
  1039  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1040  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1041  	}
  1042  
  1043  	msg, err := server.AuthDisable(ctx, &protoReq)
  1044  	return msg, metadata, err
  1045  
  1046  }
  1047  
  1048  func request_Auth_AuthStatus_0(ctx context.Context, marshaler runtime.Marshaler, client etcdserverpb.AuthClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1049  	var protoReq etcdserverpb.AuthStatusRequest
  1050  	var metadata runtime.ServerMetadata
  1051  
  1052  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1053  	if berr != nil {
  1054  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1055  	}
  1056  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1057  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1058  	}
  1059  
  1060  	msg, err := client.AuthStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1061  	return msg, metadata, err
  1062  
  1063  }
  1064  
  1065  func local_request_Auth_AuthStatus_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1066  	var protoReq etcdserverpb.AuthStatusRequest
  1067  	var metadata runtime.ServerMetadata
  1068  
  1069  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1070  	if berr != nil {
  1071  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1072  	}
  1073  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1074  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1075  	}
  1076  
  1077  	msg, err := server.AuthStatus(ctx, &protoReq)
  1078  	return msg, metadata, err
  1079  
  1080  }
  1081  
  1082  func 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) {
  1083  	var protoReq etcdserverpb.AuthenticateRequest
  1084  	var metadata runtime.ServerMetadata
  1085  
  1086  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1087  	if berr != nil {
  1088  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1089  	}
  1090  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1091  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1092  	}
  1093  
  1094  	msg, err := client.Authenticate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1095  	return msg, metadata, err
  1096  
  1097  }
  1098  
  1099  func local_request_Auth_Authenticate_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1100  	var protoReq etcdserverpb.AuthenticateRequest
  1101  	var metadata runtime.ServerMetadata
  1102  
  1103  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1104  	if berr != nil {
  1105  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1106  	}
  1107  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1108  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1109  	}
  1110  
  1111  	msg, err := server.Authenticate(ctx, &protoReq)
  1112  	return msg, metadata, err
  1113  
  1114  }
  1115  
  1116  func 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) {
  1117  	var protoReq etcdserverpb.AuthUserAddRequest
  1118  	var metadata runtime.ServerMetadata
  1119  
  1120  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1121  	if berr != nil {
  1122  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1123  	}
  1124  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1125  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1126  	}
  1127  
  1128  	msg, err := client.UserAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1129  	return msg, metadata, err
  1130  
  1131  }
  1132  
  1133  func local_request_Auth_UserAdd_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1134  	var protoReq etcdserverpb.AuthUserAddRequest
  1135  	var metadata runtime.ServerMetadata
  1136  
  1137  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1138  	if berr != nil {
  1139  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1140  	}
  1141  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1142  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1143  	}
  1144  
  1145  	msg, err := server.UserAdd(ctx, &protoReq)
  1146  	return msg, metadata, err
  1147  
  1148  }
  1149  
  1150  func 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) {
  1151  	var protoReq etcdserverpb.AuthUserGetRequest
  1152  	var metadata runtime.ServerMetadata
  1153  
  1154  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1155  	if berr != nil {
  1156  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1157  	}
  1158  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1159  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1160  	}
  1161  
  1162  	msg, err := client.UserGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1163  	return msg, metadata, err
  1164  
  1165  }
  1166  
  1167  func local_request_Auth_UserGet_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1168  	var protoReq etcdserverpb.AuthUserGetRequest
  1169  	var metadata runtime.ServerMetadata
  1170  
  1171  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1172  	if berr != nil {
  1173  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1174  	}
  1175  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1176  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1177  	}
  1178  
  1179  	msg, err := server.UserGet(ctx, &protoReq)
  1180  	return msg, metadata, err
  1181  
  1182  }
  1183  
  1184  func 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) {
  1185  	var protoReq etcdserverpb.AuthUserListRequest
  1186  	var metadata runtime.ServerMetadata
  1187  
  1188  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1189  	if berr != nil {
  1190  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1191  	}
  1192  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1193  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1194  	}
  1195  
  1196  	msg, err := client.UserList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1197  	return msg, metadata, err
  1198  
  1199  }
  1200  
  1201  func local_request_Auth_UserList_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1202  	var protoReq etcdserverpb.AuthUserListRequest
  1203  	var metadata runtime.ServerMetadata
  1204  
  1205  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1206  	if berr != nil {
  1207  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1208  	}
  1209  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1210  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1211  	}
  1212  
  1213  	msg, err := server.UserList(ctx, &protoReq)
  1214  	return msg, metadata, err
  1215  
  1216  }
  1217  
  1218  func 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) {
  1219  	var protoReq etcdserverpb.AuthUserDeleteRequest
  1220  	var metadata runtime.ServerMetadata
  1221  
  1222  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1223  	if berr != nil {
  1224  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1225  	}
  1226  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1227  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1228  	}
  1229  
  1230  	msg, err := client.UserDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1231  	return msg, metadata, err
  1232  
  1233  }
  1234  
  1235  func local_request_Auth_UserDelete_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1236  	var protoReq etcdserverpb.AuthUserDeleteRequest
  1237  	var metadata runtime.ServerMetadata
  1238  
  1239  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1240  	if berr != nil {
  1241  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1242  	}
  1243  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1244  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1245  	}
  1246  
  1247  	msg, err := server.UserDelete(ctx, &protoReq)
  1248  	return msg, metadata, err
  1249  
  1250  }
  1251  
  1252  func 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) {
  1253  	var protoReq etcdserverpb.AuthUserChangePasswordRequest
  1254  	var metadata runtime.ServerMetadata
  1255  
  1256  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1257  	if berr != nil {
  1258  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1259  	}
  1260  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1261  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1262  	}
  1263  
  1264  	msg, err := client.UserChangePassword(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1265  	return msg, metadata, err
  1266  
  1267  }
  1268  
  1269  func local_request_Auth_UserChangePassword_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1270  	var protoReq etcdserverpb.AuthUserChangePasswordRequest
  1271  	var metadata runtime.ServerMetadata
  1272  
  1273  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1274  	if berr != nil {
  1275  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1276  	}
  1277  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1278  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1279  	}
  1280  
  1281  	msg, err := server.UserChangePassword(ctx, &protoReq)
  1282  	return msg, metadata, err
  1283  
  1284  }
  1285  
  1286  func 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) {
  1287  	var protoReq etcdserverpb.AuthUserGrantRoleRequest
  1288  	var metadata runtime.ServerMetadata
  1289  
  1290  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1291  	if berr != nil {
  1292  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1293  	}
  1294  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1295  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1296  	}
  1297  
  1298  	msg, err := client.UserGrantRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1299  	return msg, metadata, err
  1300  
  1301  }
  1302  
  1303  func local_request_Auth_UserGrantRole_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1304  	var protoReq etcdserverpb.AuthUserGrantRoleRequest
  1305  	var metadata runtime.ServerMetadata
  1306  
  1307  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1308  	if berr != nil {
  1309  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1310  	}
  1311  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1312  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1313  	}
  1314  
  1315  	msg, err := server.UserGrantRole(ctx, &protoReq)
  1316  	return msg, metadata, err
  1317  
  1318  }
  1319  
  1320  func 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) {
  1321  	var protoReq etcdserverpb.AuthUserRevokeRoleRequest
  1322  	var metadata runtime.ServerMetadata
  1323  
  1324  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1325  	if berr != nil {
  1326  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1327  	}
  1328  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1329  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1330  	}
  1331  
  1332  	msg, err := client.UserRevokeRole(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1333  	return msg, metadata, err
  1334  
  1335  }
  1336  
  1337  func local_request_Auth_UserRevokeRole_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1338  	var protoReq etcdserverpb.AuthUserRevokeRoleRequest
  1339  	var metadata runtime.ServerMetadata
  1340  
  1341  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1342  	if berr != nil {
  1343  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1344  	}
  1345  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1346  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1347  	}
  1348  
  1349  	msg, err := server.UserRevokeRole(ctx, &protoReq)
  1350  	return msg, metadata, err
  1351  
  1352  }
  1353  
  1354  func 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) {
  1355  	var protoReq etcdserverpb.AuthRoleAddRequest
  1356  	var metadata runtime.ServerMetadata
  1357  
  1358  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1359  	if berr != nil {
  1360  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1361  	}
  1362  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1363  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1364  	}
  1365  
  1366  	msg, err := client.RoleAdd(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1367  	return msg, metadata, err
  1368  
  1369  }
  1370  
  1371  func local_request_Auth_RoleAdd_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1372  	var protoReq etcdserverpb.AuthRoleAddRequest
  1373  	var metadata runtime.ServerMetadata
  1374  
  1375  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1376  	if berr != nil {
  1377  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1378  	}
  1379  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1380  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1381  	}
  1382  
  1383  	msg, err := server.RoleAdd(ctx, &protoReq)
  1384  	return msg, metadata, err
  1385  
  1386  }
  1387  
  1388  func 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) {
  1389  	var protoReq etcdserverpb.AuthRoleGetRequest
  1390  	var metadata runtime.ServerMetadata
  1391  
  1392  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1393  	if berr != nil {
  1394  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1395  	}
  1396  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1397  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1398  	}
  1399  
  1400  	msg, err := client.RoleGet(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1401  	return msg, metadata, err
  1402  
  1403  }
  1404  
  1405  func local_request_Auth_RoleGet_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1406  	var protoReq etcdserverpb.AuthRoleGetRequest
  1407  	var metadata runtime.ServerMetadata
  1408  
  1409  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1410  	if berr != nil {
  1411  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1412  	}
  1413  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1414  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1415  	}
  1416  
  1417  	msg, err := server.RoleGet(ctx, &protoReq)
  1418  	return msg, metadata, err
  1419  
  1420  }
  1421  
  1422  func 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) {
  1423  	var protoReq etcdserverpb.AuthRoleListRequest
  1424  	var metadata runtime.ServerMetadata
  1425  
  1426  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1427  	if berr != nil {
  1428  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1429  	}
  1430  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1431  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1432  	}
  1433  
  1434  	msg, err := client.RoleList(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1435  	return msg, metadata, err
  1436  
  1437  }
  1438  
  1439  func local_request_Auth_RoleList_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1440  	var protoReq etcdserverpb.AuthRoleListRequest
  1441  	var metadata runtime.ServerMetadata
  1442  
  1443  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1444  	if berr != nil {
  1445  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1446  	}
  1447  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1448  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1449  	}
  1450  
  1451  	msg, err := server.RoleList(ctx, &protoReq)
  1452  	return msg, metadata, err
  1453  
  1454  }
  1455  
  1456  func 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) {
  1457  	var protoReq etcdserverpb.AuthRoleDeleteRequest
  1458  	var metadata runtime.ServerMetadata
  1459  
  1460  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1461  	if berr != nil {
  1462  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1463  	}
  1464  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1465  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1466  	}
  1467  
  1468  	msg, err := client.RoleDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1469  	return msg, metadata, err
  1470  
  1471  }
  1472  
  1473  func local_request_Auth_RoleDelete_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1474  	var protoReq etcdserverpb.AuthRoleDeleteRequest
  1475  	var metadata runtime.ServerMetadata
  1476  
  1477  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1478  	if berr != nil {
  1479  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1480  	}
  1481  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1482  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1483  	}
  1484  
  1485  	msg, err := server.RoleDelete(ctx, &protoReq)
  1486  	return msg, metadata, err
  1487  
  1488  }
  1489  
  1490  func 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) {
  1491  	var protoReq etcdserverpb.AuthRoleGrantPermissionRequest
  1492  	var metadata runtime.ServerMetadata
  1493  
  1494  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1495  	if berr != nil {
  1496  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1497  	}
  1498  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1499  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1500  	}
  1501  
  1502  	msg, err := client.RoleGrantPermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1503  	return msg, metadata, err
  1504  
  1505  }
  1506  
  1507  func local_request_Auth_RoleGrantPermission_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1508  	var protoReq etcdserverpb.AuthRoleGrantPermissionRequest
  1509  	var metadata runtime.ServerMetadata
  1510  
  1511  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1512  	if berr != nil {
  1513  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1514  	}
  1515  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1516  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1517  	}
  1518  
  1519  	msg, err := server.RoleGrantPermission(ctx, &protoReq)
  1520  	return msg, metadata, err
  1521  
  1522  }
  1523  
  1524  func 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) {
  1525  	var protoReq etcdserverpb.AuthRoleRevokePermissionRequest
  1526  	var metadata runtime.ServerMetadata
  1527  
  1528  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1529  	if berr != nil {
  1530  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1531  	}
  1532  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1533  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1534  	}
  1535  
  1536  	msg, err := client.RoleRevokePermission(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
  1537  	return msg, metadata, err
  1538  
  1539  }
  1540  
  1541  func local_request_Auth_RoleRevokePermission_0(ctx context.Context, marshaler runtime.Marshaler, server etcdserverpb.AuthServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
  1542  	var protoReq etcdserverpb.AuthRoleRevokePermissionRequest
  1543  	var metadata runtime.ServerMetadata
  1544  
  1545  	newReader, berr := utilities.IOReaderFactory(req.Body)
  1546  	if berr != nil {
  1547  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
  1548  	}
  1549  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
  1550  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
  1551  	}
  1552  
  1553  	msg, err := server.RoleRevokePermission(ctx, &protoReq)
  1554  	return msg, metadata, err
  1555  
  1556  }
  1557  
  1558  // etcdserverpb.RegisterKVHandlerServer registers the http handlers for service KV to "mux".
  1559  // UnaryRPC     :call etcdserverpb.KVServer directly.
  1560  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
  1561  func RegisterKVHandlerServer(ctx context.Context, mux *runtime.ServeMux, server etcdserverpb.KVServer) error {
  1562  
  1563  	mux.Handle("POST", pattern_KV_Range_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1564  		ctx, cancel := context.WithCancel(req.Context())
  1565  		defer cancel()
  1566  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1567  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1568  		if err != nil {
  1569  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1570  			return
  1571  		}
  1572  		resp, md, err := local_request_KV_Range_0(rctx, inboundMarshaler, server, req, pathParams)
  1573  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1574  		if err != nil {
  1575  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1576  			return
  1577  		}
  1578  
  1579  		forward_KV_Range_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1580  
  1581  	})
  1582  
  1583  	mux.Handle("POST", pattern_KV_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1584  		ctx, cancel := context.WithCancel(req.Context())
  1585  		defer cancel()
  1586  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1587  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1588  		if err != nil {
  1589  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1590  			return
  1591  		}
  1592  		resp, md, err := local_request_KV_Put_0(rctx, inboundMarshaler, server, req, pathParams)
  1593  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1594  		if err != nil {
  1595  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1596  			return
  1597  		}
  1598  
  1599  		forward_KV_Put_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1600  
  1601  	})
  1602  
  1603  	mux.Handle("POST", pattern_KV_DeleteRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1604  		ctx, cancel := context.WithCancel(req.Context())
  1605  		defer cancel()
  1606  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1607  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1608  		if err != nil {
  1609  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1610  			return
  1611  		}
  1612  		resp, md, err := local_request_KV_DeleteRange_0(rctx, inboundMarshaler, server, req, pathParams)
  1613  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1614  		if err != nil {
  1615  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1616  			return
  1617  		}
  1618  
  1619  		forward_KV_DeleteRange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1620  
  1621  	})
  1622  
  1623  	mux.Handle("POST", pattern_KV_Txn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1624  		ctx, cancel := context.WithCancel(req.Context())
  1625  		defer cancel()
  1626  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1627  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1628  		if err != nil {
  1629  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1630  			return
  1631  		}
  1632  		resp, md, err := local_request_KV_Txn_0(rctx, inboundMarshaler, server, req, pathParams)
  1633  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1634  		if err != nil {
  1635  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1636  			return
  1637  		}
  1638  
  1639  		forward_KV_Txn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1640  
  1641  	})
  1642  
  1643  	mux.Handle("POST", pattern_KV_Compact_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1644  		ctx, cancel := context.WithCancel(req.Context())
  1645  		defer cancel()
  1646  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1647  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1648  		if err != nil {
  1649  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1650  			return
  1651  		}
  1652  		resp, md, err := local_request_KV_Compact_0(rctx, inboundMarshaler, server, req, pathParams)
  1653  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1654  		if err != nil {
  1655  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1656  			return
  1657  		}
  1658  
  1659  		forward_KV_Compact_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1660  
  1661  	})
  1662  
  1663  	return nil
  1664  }
  1665  
  1666  // etcdserverpb.RegisterWatchHandlerServer registers the http handlers for service Watch to "mux".
  1667  // UnaryRPC     :call etcdserverpb.WatchServer directly.
  1668  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
  1669  func RegisterWatchHandlerServer(ctx context.Context, mux *runtime.ServeMux, server etcdserverpb.WatchServer) error {
  1670  
  1671  	mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1672  		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
  1673  		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1674  		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1675  		return
  1676  	})
  1677  
  1678  	return nil
  1679  }
  1680  
  1681  // etcdserverpb.RegisterLeaseHandlerServer registers the http handlers for service Lease to "mux".
  1682  // UnaryRPC     :call etcdserverpb.LeaseServer directly.
  1683  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
  1684  func RegisterLeaseHandlerServer(ctx context.Context, mux *runtime.ServeMux, server etcdserverpb.LeaseServer) error {
  1685  
  1686  	mux.Handle("POST", pattern_Lease_LeaseGrant_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1687  		ctx, cancel := context.WithCancel(req.Context())
  1688  		defer cancel()
  1689  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1690  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1691  		if err != nil {
  1692  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1693  			return
  1694  		}
  1695  		resp, md, err := local_request_Lease_LeaseGrant_0(rctx, inboundMarshaler, server, req, pathParams)
  1696  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1697  		if err != nil {
  1698  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1699  			return
  1700  		}
  1701  
  1702  		forward_Lease_LeaseGrant_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1703  
  1704  	})
  1705  
  1706  	mux.Handle("POST", pattern_Lease_LeaseRevoke_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1707  		ctx, cancel := context.WithCancel(req.Context())
  1708  		defer cancel()
  1709  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1710  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1711  		if err != nil {
  1712  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1713  			return
  1714  		}
  1715  		resp, md, err := local_request_Lease_LeaseRevoke_0(rctx, inboundMarshaler, server, req, pathParams)
  1716  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1717  		if err != nil {
  1718  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1719  			return
  1720  		}
  1721  
  1722  		forward_Lease_LeaseRevoke_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1723  
  1724  	})
  1725  
  1726  	mux.Handle("POST", pattern_Lease_LeaseRevoke_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1727  		ctx, cancel := context.WithCancel(req.Context())
  1728  		defer cancel()
  1729  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1730  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1731  		if err != nil {
  1732  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1733  			return
  1734  		}
  1735  		resp, md, err := local_request_Lease_LeaseRevoke_1(rctx, inboundMarshaler, server, req, pathParams)
  1736  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1737  		if err != nil {
  1738  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1739  			return
  1740  		}
  1741  
  1742  		forward_Lease_LeaseRevoke_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1743  
  1744  	})
  1745  
  1746  	mux.Handle("POST", pattern_Lease_LeaseKeepAlive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1747  		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
  1748  		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1749  		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1750  		return
  1751  	})
  1752  
  1753  	mux.Handle("POST", pattern_Lease_LeaseTimeToLive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1754  		ctx, cancel := context.WithCancel(req.Context())
  1755  		defer cancel()
  1756  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1757  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1758  		if err != nil {
  1759  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1760  			return
  1761  		}
  1762  		resp, md, err := local_request_Lease_LeaseTimeToLive_0(rctx, inboundMarshaler, server, req, pathParams)
  1763  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1764  		if err != nil {
  1765  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1766  			return
  1767  		}
  1768  
  1769  		forward_Lease_LeaseTimeToLive_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1770  
  1771  	})
  1772  
  1773  	mux.Handle("POST", pattern_Lease_LeaseTimeToLive_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1774  		ctx, cancel := context.WithCancel(req.Context())
  1775  		defer cancel()
  1776  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1777  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1778  		if err != nil {
  1779  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1780  			return
  1781  		}
  1782  		resp, md, err := local_request_Lease_LeaseTimeToLive_1(rctx, inboundMarshaler, server, req, pathParams)
  1783  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1784  		if err != nil {
  1785  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1786  			return
  1787  		}
  1788  
  1789  		forward_Lease_LeaseTimeToLive_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1790  
  1791  	})
  1792  
  1793  	mux.Handle("POST", pattern_Lease_LeaseLeases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1794  		ctx, cancel := context.WithCancel(req.Context())
  1795  		defer cancel()
  1796  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1797  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1798  		if err != nil {
  1799  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1800  			return
  1801  		}
  1802  		resp, md, err := local_request_Lease_LeaseLeases_0(rctx, inboundMarshaler, server, req, pathParams)
  1803  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1804  		if err != nil {
  1805  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1806  			return
  1807  		}
  1808  
  1809  		forward_Lease_LeaseLeases_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1810  
  1811  	})
  1812  
  1813  	mux.Handle("POST", pattern_Lease_LeaseLeases_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1814  		ctx, cancel := context.WithCancel(req.Context())
  1815  		defer cancel()
  1816  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1817  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1818  		if err != nil {
  1819  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1820  			return
  1821  		}
  1822  		resp, md, err := local_request_Lease_LeaseLeases_1(rctx, inboundMarshaler, server, req, pathParams)
  1823  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1824  		if err != nil {
  1825  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1826  			return
  1827  		}
  1828  
  1829  		forward_Lease_LeaseLeases_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1830  
  1831  	})
  1832  
  1833  	return nil
  1834  }
  1835  
  1836  // etcdserverpb.RegisterClusterHandlerServer registers the http handlers for service Cluster to "mux".
  1837  // UnaryRPC     :call etcdserverpb.ClusterServer directly.
  1838  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
  1839  func RegisterClusterHandlerServer(ctx context.Context, mux *runtime.ServeMux, server etcdserverpb.ClusterServer) error {
  1840  
  1841  	mux.Handle("POST", pattern_Cluster_MemberAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1842  		ctx, cancel := context.WithCancel(req.Context())
  1843  		defer cancel()
  1844  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1845  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1846  		if err != nil {
  1847  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1848  			return
  1849  		}
  1850  		resp, md, err := local_request_Cluster_MemberAdd_0(rctx, inboundMarshaler, server, req, pathParams)
  1851  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1852  		if err != nil {
  1853  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1854  			return
  1855  		}
  1856  
  1857  		forward_Cluster_MemberAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1858  
  1859  	})
  1860  
  1861  	mux.Handle("POST", pattern_Cluster_MemberRemove_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1862  		ctx, cancel := context.WithCancel(req.Context())
  1863  		defer cancel()
  1864  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1865  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1866  		if err != nil {
  1867  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1868  			return
  1869  		}
  1870  		resp, md, err := local_request_Cluster_MemberRemove_0(rctx, inboundMarshaler, server, req, pathParams)
  1871  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1872  		if err != nil {
  1873  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1874  			return
  1875  		}
  1876  
  1877  		forward_Cluster_MemberRemove_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1878  
  1879  	})
  1880  
  1881  	mux.Handle("POST", pattern_Cluster_MemberUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1882  		ctx, cancel := context.WithCancel(req.Context())
  1883  		defer cancel()
  1884  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1885  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1886  		if err != nil {
  1887  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1888  			return
  1889  		}
  1890  		resp, md, err := local_request_Cluster_MemberUpdate_0(rctx, inboundMarshaler, server, 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_Cluster_MemberUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1898  
  1899  	})
  1900  
  1901  	mux.Handle("POST", pattern_Cluster_MemberList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1902  		ctx, cancel := context.WithCancel(req.Context())
  1903  		defer cancel()
  1904  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1905  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1906  		if err != nil {
  1907  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1908  			return
  1909  		}
  1910  		resp, md, err := local_request_Cluster_MemberList_0(rctx, inboundMarshaler, server, req, pathParams)
  1911  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1912  		if err != nil {
  1913  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1914  			return
  1915  		}
  1916  
  1917  		forward_Cluster_MemberList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1918  
  1919  	})
  1920  
  1921  	mux.Handle("POST", pattern_Cluster_MemberPromote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1922  		ctx, cancel := context.WithCancel(req.Context())
  1923  		defer cancel()
  1924  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1925  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1926  		if err != nil {
  1927  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1928  			return
  1929  		}
  1930  		resp, md, err := local_request_Cluster_MemberPromote_0(rctx, inboundMarshaler, server, req, pathParams)
  1931  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1932  		if err != nil {
  1933  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1934  			return
  1935  		}
  1936  
  1937  		forward_Cluster_MemberPromote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1938  
  1939  	})
  1940  
  1941  	return nil
  1942  }
  1943  
  1944  // etcdserverpb.RegisterMaintenanceHandlerServer registers the http handlers for service Maintenance to "mux".
  1945  // UnaryRPC     :call etcdserverpb.MaintenanceServer directly.
  1946  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
  1947  func RegisterMaintenanceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server etcdserverpb.MaintenanceServer) error {
  1948  
  1949  	mux.Handle("POST", pattern_Maintenance_Alarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1950  		ctx, cancel := context.WithCancel(req.Context())
  1951  		defer cancel()
  1952  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1953  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1954  		if err != nil {
  1955  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1956  			return
  1957  		}
  1958  		resp, md, err := local_request_Maintenance_Alarm_0(rctx, inboundMarshaler, server, req, pathParams)
  1959  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1960  		if err != nil {
  1961  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1962  			return
  1963  		}
  1964  
  1965  		forward_Maintenance_Alarm_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1966  
  1967  	})
  1968  
  1969  	mux.Handle("POST", pattern_Maintenance_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1970  		ctx, cancel := context.WithCancel(req.Context())
  1971  		defer cancel()
  1972  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1973  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1974  		if err != nil {
  1975  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1976  			return
  1977  		}
  1978  		resp, md, err := local_request_Maintenance_Status_0(rctx, inboundMarshaler, server, req, pathParams)
  1979  		ctx = runtime.NewServerMetadataContext(ctx, md)
  1980  		if err != nil {
  1981  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1982  			return
  1983  		}
  1984  
  1985  		forward_Maintenance_Status_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  1986  
  1987  	})
  1988  
  1989  	mux.Handle("POST", pattern_Maintenance_Defragment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  1990  		ctx, cancel := context.WithCancel(req.Context())
  1991  		defer cancel()
  1992  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  1993  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  1994  		if err != nil {
  1995  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  1996  			return
  1997  		}
  1998  		resp, md, err := local_request_Maintenance_Defragment_0(rctx, inboundMarshaler, server, req, pathParams)
  1999  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2000  		if err != nil {
  2001  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2002  			return
  2003  		}
  2004  
  2005  		forward_Maintenance_Defragment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2006  
  2007  	})
  2008  
  2009  	mux.Handle("POST", pattern_Maintenance_Hash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2010  		ctx, cancel := context.WithCancel(req.Context())
  2011  		defer cancel()
  2012  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2013  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2014  		if err != nil {
  2015  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2016  			return
  2017  		}
  2018  		resp, md, err := local_request_Maintenance_Hash_0(rctx, inboundMarshaler, server, req, pathParams)
  2019  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2020  		if err != nil {
  2021  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2022  			return
  2023  		}
  2024  
  2025  		forward_Maintenance_Hash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2026  
  2027  	})
  2028  
  2029  	mux.Handle("POST", pattern_Maintenance_HashKV_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2030  		ctx, cancel := context.WithCancel(req.Context())
  2031  		defer cancel()
  2032  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2033  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2034  		if err != nil {
  2035  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2036  			return
  2037  		}
  2038  		resp, md, err := local_request_Maintenance_HashKV_0(rctx, inboundMarshaler, server, req, pathParams)
  2039  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2040  		if err != nil {
  2041  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2042  			return
  2043  		}
  2044  
  2045  		forward_Maintenance_HashKV_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2046  
  2047  	})
  2048  
  2049  	mux.Handle("POST", pattern_Maintenance_Snapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2050  		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
  2051  		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2052  		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2053  		return
  2054  	})
  2055  
  2056  	mux.Handle("POST", pattern_Maintenance_MoveLeader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2057  		ctx, cancel := context.WithCancel(req.Context())
  2058  		defer cancel()
  2059  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2060  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2061  		if err != nil {
  2062  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2063  			return
  2064  		}
  2065  		resp, md, err := local_request_Maintenance_MoveLeader_0(rctx, inboundMarshaler, server, req, pathParams)
  2066  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2067  		if err != nil {
  2068  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2069  			return
  2070  		}
  2071  
  2072  		forward_Maintenance_MoveLeader_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2073  
  2074  	})
  2075  
  2076  	mux.Handle("POST", pattern_Maintenance_Downgrade_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2077  		ctx, cancel := context.WithCancel(req.Context())
  2078  		defer cancel()
  2079  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2080  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2081  		if err != nil {
  2082  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2083  			return
  2084  		}
  2085  		resp, md, err := local_request_Maintenance_Downgrade_0(rctx, inboundMarshaler, server, req, pathParams)
  2086  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2087  		if err != nil {
  2088  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2089  			return
  2090  		}
  2091  
  2092  		forward_Maintenance_Downgrade_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2093  
  2094  	})
  2095  
  2096  	return nil
  2097  }
  2098  
  2099  // etcdserverpb.RegisterAuthHandlerServer registers the http handlers for service Auth to "mux".
  2100  // UnaryRPC     :call etcdserverpb.AuthServer directly.
  2101  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
  2102  func RegisterAuthHandlerServer(ctx context.Context, mux *runtime.ServeMux, server etcdserverpb.AuthServer) error {
  2103  
  2104  	mux.Handle("POST", pattern_Auth_AuthEnable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2105  		ctx, cancel := context.WithCancel(req.Context())
  2106  		defer cancel()
  2107  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2108  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2109  		if err != nil {
  2110  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2111  			return
  2112  		}
  2113  		resp, md, err := local_request_Auth_AuthEnable_0(rctx, inboundMarshaler, server, req, pathParams)
  2114  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2115  		if err != nil {
  2116  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2117  			return
  2118  		}
  2119  
  2120  		forward_Auth_AuthEnable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2121  
  2122  	})
  2123  
  2124  	mux.Handle("POST", pattern_Auth_AuthDisable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2125  		ctx, cancel := context.WithCancel(req.Context())
  2126  		defer cancel()
  2127  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2128  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2129  		if err != nil {
  2130  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2131  			return
  2132  		}
  2133  		resp, md, err := local_request_Auth_AuthDisable_0(rctx, inboundMarshaler, server, req, pathParams)
  2134  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2135  		if err != nil {
  2136  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2137  			return
  2138  		}
  2139  
  2140  		forward_Auth_AuthDisable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2141  
  2142  	})
  2143  
  2144  	mux.Handle("POST", pattern_Auth_AuthStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2145  		ctx, cancel := context.WithCancel(req.Context())
  2146  		defer cancel()
  2147  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2148  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2149  		if err != nil {
  2150  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2151  			return
  2152  		}
  2153  		resp, md, err := local_request_Auth_AuthStatus_0(rctx, inboundMarshaler, server, req, pathParams)
  2154  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2155  		if err != nil {
  2156  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2157  			return
  2158  		}
  2159  
  2160  		forward_Auth_AuthStatus_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2161  
  2162  	})
  2163  
  2164  	mux.Handle("POST", pattern_Auth_Authenticate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2165  		ctx, cancel := context.WithCancel(req.Context())
  2166  		defer cancel()
  2167  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2168  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2169  		if err != nil {
  2170  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2171  			return
  2172  		}
  2173  		resp, md, err := local_request_Auth_Authenticate_0(rctx, inboundMarshaler, server, req, pathParams)
  2174  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2175  		if err != nil {
  2176  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2177  			return
  2178  		}
  2179  
  2180  		forward_Auth_Authenticate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2181  
  2182  	})
  2183  
  2184  	mux.Handle("POST", pattern_Auth_UserAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2185  		ctx, cancel := context.WithCancel(req.Context())
  2186  		defer cancel()
  2187  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2188  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2189  		if err != nil {
  2190  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2191  			return
  2192  		}
  2193  		resp, md, err := local_request_Auth_UserAdd_0(rctx, inboundMarshaler, server, req, pathParams)
  2194  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2195  		if err != nil {
  2196  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2197  			return
  2198  		}
  2199  
  2200  		forward_Auth_UserAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2201  
  2202  	})
  2203  
  2204  	mux.Handle("POST", pattern_Auth_UserGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2205  		ctx, cancel := context.WithCancel(req.Context())
  2206  		defer cancel()
  2207  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2208  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2209  		if err != nil {
  2210  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2211  			return
  2212  		}
  2213  		resp, md, err := local_request_Auth_UserGet_0(rctx, inboundMarshaler, server, req, pathParams)
  2214  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2215  		if err != nil {
  2216  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2217  			return
  2218  		}
  2219  
  2220  		forward_Auth_UserGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2221  
  2222  	})
  2223  
  2224  	mux.Handle("POST", pattern_Auth_UserList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2225  		ctx, cancel := context.WithCancel(req.Context())
  2226  		defer cancel()
  2227  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2228  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2229  		if err != nil {
  2230  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2231  			return
  2232  		}
  2233  		resp, md, err := local_request_Auth_UserList_0(rctx, inboundMarshaler, server, req, pathParams)
  2234  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2235  		if err != nil {
  2236  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2237  			return
  2238  		}
  2239  
  2240  		forward_Auth_UserList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2241  
  2242  	})
  2243  
  2244  	mux.Handle("POST", pattern_Auth_UserDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2245  		ctx, cancel := context.WithCancel(req.Context())
  2246  		defer cancel()
  2247  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2248  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2249  		if err != nil {
  2250  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2251  			return
  2252  		}
  2253  		resp, md, err := local_request_Auth_UserDelete_0(rctx, inboundMarshaler, server, req, pathParams)
  2254  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2255  		if err != nil {
  2256  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2257  			return
  2258  		}
  2259  
  2260  		forward_Auth_UserDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2261  
  2262  	})
  2263  
  2264  	mux.Handle("POST", pattern_Auth_UserChangePassword_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2265  		ctx, cancel := context.WithCancel(req.Context())
  2266  		defer cancel()
  2267  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2268  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2269  		if err != nil {
  2270  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2271  			return
  2272  		}
  2273  		resp, md, err := local_request_Auth_UserChangePassword_0(rctx, inboundMarshaler, server, req, pathParams)
  2274  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2275  		if err != nil {
  2276  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2277  			return
  2278  		}
  2279  
  2280  		forward_Auth_UserChangePassword_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2281  
  2282  	})
  2283  
  2284  	mux.Handle("POST", pattern_Auth_UserGrantRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2285  		ctx, cancel := context.WithCancel(req.Context())
  2286  		defer cancel()
  2287  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2288  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2289  		if err != nil {
  2290  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2291  			return
  2292  		}
  2293  		resp, md, err := local_request_Auth_UserGrantRole_0(rctx, inboundMarshaler, server, req, pathParams)
  2294  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2295  		if err != nil {
  2296  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2297  			return
  2298  		}
  2299  
  2300  		forward_Auth_UserGrantRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2301  
  2302  	})
  2303  
  2304  	mux.Handle("POST", pattern_Auth_UserRevokeRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2305  		ctx, cancel := context.WithCancel(req.Context())
  2306  		defer cancel()
  2307  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2308  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2309  		if err != nil {
  2310  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2311  			return
  2312  		}
  2313  		resp, md, err := local_request_Auth_UserRevokeRole_0(rctx, inboundMarshaler, server, req, pathParams)
  2314  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2315  		if err != nil {
  2316  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2317  			return
  2318  		}
  2319  
  2320  		forward_Auth_UserRevokeRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2321  
  2322  	})
  2323  
  2324  	mux.Handle("POST", pattern_Auth_RoleAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2325  		ctx, cancel := context.WithCancel(req.Context())
  2326  		defer cancel()
  2327  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2328  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2329  		if err != nil {
  2330  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2331  			return
  2332  		}
  2333  		resp, md, err := local_request_Auth_RoleAdd_0(rctx, inboundMarshaler, server, req, pathParams)
  2334  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2335  		if err != nil {
  2336  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2337  			return
  2338  		}
  2339  
  2340  		forward_Auth_RoleAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2341  
  2342  	})
  2343  
  2344  	mux.Handle("POST", pattern_Auth_RoleGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2345  		ctx, cancel := context.WithCancel(req.Context())
  2346  		defer cancel()
  2347  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2348  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2349  		if err != nil {
  2350  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2351  			return
  2352  		}
  2353  		resp, md, err := local_request_Auth_RoleGet_0(rctx, inboundMarshaler, server, req, pathParams)
  2354  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2355  		if err != nil {
  2356  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2357  			return
  2358  		}
  2359  
  2360  		forward_Auth_RoleGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2361  
  2362  	})
  2363  
  2364  	mux.Handle("POST", pattern_Auth_RoleList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2365  		ctx, cancel := context.WithCancel(req.Context())
  2366  		defer cancel()
  2367  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2368  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2369  		if err != nil {
  2370  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2371  			return
  2372  		}
  2373  		resp, md, err := local_request_Auth_RoleList_0(rctx, inboundMarshaler, server, req, pathParams)
  2374  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2375  		if err != nil {
  2376  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2377  			return
  2378  		}
  2379  
  2380  		forward_Auth_RoleList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2381  
  2382  	})
  2383  
  2384  	mux.Handle("POST", pattern_Auth_RoleDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2385  		ctx, cancel := context.WithCancel(req.Context())
  2386  		defer cancel()
  2387  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2388  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2389  		if err != nil {
  2390  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2391  			return
  2392  		}
  2393  		resp, md, err := local_request_Auth_RoleDelete_0(rctx, inboundMarshaler, server, req, pathParams)
  2394  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2395  		if err != nil {
  2396  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2397  			return
  2398  		}
  2399  
  2400  		forward_Auth_RoleDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2401  
  2402  	})
  2403  
  2404  	mux.Handle("POST", pattern_Auth_RoleGrantPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2405  		ctx, cancel := context.WithCancel(req.Context())
  2406  		defer cancel()
  2407  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2408  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2409  		if err != nil {
  2410  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2411  			return
  2412  		}
  2413  		resp, md, err := local_request_Auth_RoleGrantPermission_0(rctx, inboundMarshaler, server, req, pathParams)
  2414  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2415  		if err != nil {
  2416  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2417  			return
  2418  		}
  2419  
  2420  		forward_Auth_RoleGrantPermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2421  
  2422  	})
  2423  
  2424  	mux.Handle("POST", pattern_Auth_RoleRevokePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2425  		ctx, cancel := context.WithCancel(req.Context())
  2426  		defer cancel()
  2427  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2428  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
  2429  		if err != nil {
  2430  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2431  			return
  2432  		}
  2433  		resp, md, err := local_request_Auth_RoleRevokePermission_0(rctx, inboundMarshaler, server, req, pathParams)
  2434  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2435  		if err != nil {
  2436  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2437  			return
  2438  		}
  2439  
  2440  		forward_Auth_RoleRevokePermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2441  
  2442  	})
  2443  
  2444  	return nil
  2445  }
  2446  
  2447  // RegisterKVHandlerFromEndpoint is same as RegisterKVHandler but
  2448  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  2449  func RegisterKVHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  2450  	conn, err := grpc.Dial(endpoint, opts...)
  2451  	if err != nil {
  2452  		return err
  2453  	}
  2454  	defer func() {
  2455  		if err != nil {
  2456  			if cerr := conn.Close(); cerr != nil {
  2457  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2458  			}
  2459  			return
  2460  		}
  2461  		go func() {
  2462  			<-ctx.Done()
  2463  			if cerr := conn.Close(); cerr != nil {
  2464  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2465  			}
  2466  		}()
  2467  	}()
  2468  
  2469  	return RegisterKVHandler(ctx, mux, conn)
  2470  }
  2471  
  2472  // RegisterKVHandler registers the http handlers for service KV to "mux".
  2473  // The handlers forward requests to the grpc endpoint over "conn".
  2474  func RegisterKVHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  2475  	return RegisterKVHandlerClient(ctx, mux, etcdserverpb.NewKVClient(conn))
  2476  }
  2477  
  2478  // etcdserverpb.RegisterKVHandlerClient registers the http handlers for service KV
  2479  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "KVClient".
  2480  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "KVClient"
  2481  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  2482  // "KVClient" to call the correct interceptors.
  2483  func RegisterKVHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.KVClient) error {
  2484  
  2485  	mux.Handle("POST", pattern_KV_Range_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2486  		ctx, cancel := context.WithCancel(req.Context())
  2487  		defer cancel()
  2488  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2489  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2490  		if err != nil {
  2491  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2492  			return
  2493  		}
  2494  		resp, md, err := request_KV_Range_0(rctx, inboundMarshaler, client, req, pathParams)
  2495  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2496  		if err != nil {
  2497  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2498  			return
  2499  		}
  2500  
  2501  		forward_KV_Range_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2502  
  2503  	})
  2504  
  2505  	mux.Handle("POST", pattern_KV_Put_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2506  		ctx, cancel := context.WithCancel(req.Context())
  2507  		defer cancel()
  2508  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2509  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2510  		if err != nil {
  2511  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2512  			return
  2513  		}
  2514  		resp, md, err := request_KV_Put_0(rctx, inboundMarshaler, client, req, pathParams)
  2515  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2516  		if err != nil {
  2517  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2518  			return
  2519  		}
  2520  
  2521  		forward_KV_Put_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2522  
  2523  	})
  2524  
  2525  	mux.Handle("POST", pattern_KV_DeleteRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2526  		ctx, cancel := context.WithCancel(req.Context())
  2527  		defer cancel()
  2528  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2529  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2530  		if err != nil {
  2531  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2532  			return
  2533  		}
  2534  		resp, md, err := request_KV_DeleteRange_0(rctx, inboundMarshaler, client, req, pathParams)
  2535  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2536  		if err != nil {
  2537  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2538  			return
  2539  		}
  2540  
  2541  		forward_KV_DeleteRange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2542  
  2543  	})
  2544  
  2545  	mux.Handle("POST", pattern_KV_Txn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2546  		ctx, cancel := context.WithCancel(req.Context())
  2547  		defer cancel()
  2548  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2549  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2550  		if err != nil {
  2551  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2552  			return
  2553  		}
  2554  		resp, md, err := request_KV_Txn_0(rctx, inboundMarshaler, client, req, pathParams)
  2555  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2556  		if err != nil {
  2557  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2558  			return
  2559  		}
  2560  
  2561  		forward_KV_Txn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2562  
  2563  	})
  2564  
  2565  	mux.Handle("POST", pattern_KV_Compact_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2566  		ctx, cancel := context.WithCancel(req.Context())
  2567  		defer cancel()
  2568  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2569  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2570  		if err != nil {
  2571  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2572  			return
  2573  		}
  2574  		resp, md, err := request_KV_Compact_0(rctx, inboundMarshaler, client, req, pathParams)
  2575  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2576  		if err != nil {
  2577  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2578  			return
  2579  		}
  2580  
  2581  		forward_KV_Compact_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2582  
  2583  	})
  2584  
  2585  	return nil
  2586  }
  2587  
  2588  var (
  2589  	pattern_KV_Range_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "range"}, "", runtime.AssumeColonVerbOpt(true)))
  2590  
  2591  	pattern_KV_Put_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "put"}, "", runtime.AssumeColonVerbOpt(true)))
  2592  
  2593  	pattern_KV_DeleteRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "deleterange"}, "", runtime.AssumeColonVerbOpt(true)))
  2594  
  2595  	pattern_KV_Txn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "txn"}, "", runtime.AssumeColonVerbOpt(true)))
  2596  
  2597  	pattern_KV_Compact_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "kv", "compaction"}, "", runtime.AssumeColonVerbOpt(true)))
  2598  )
  2599  
  2600  var (
  2601  	forward_KV_Range_0 = runtime.ForwardResponseMessage
  2602  
  2603  	forward_KV_Put_0 = runtime.ForwardResponseMessage
  2604  
  2605  	forward_KV_DeleteRange_0 = runtime.ForwardResponseMessage
  2606  
  2607  	forward_KV_Txn_0 = runtime.ForwardResponseMessage
  2608  
  2609  	forward_KV_Compact_0 = runtime.ForwardResponseMessage
  2610  )
  2611  
  2612  // RegisterWatchHandlerFromEndpoint is same as RegisterWatchHandler but
  2613  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  2614  func RegisterWatchHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  2615  	conn, err := grpc.Dial(endpoint, opts...)
  2616  	if err != nil {
  2617  		return err
  2618  	}
  2619  	defer func() {
  2620  		if err != nil {
  2621  			if cerr := conn.Close(); cerr != nil {
  2622  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2623  			}
  2624  			return
  2625  		}
  2626  		go func() {
  2627  			<-ctx.Done()
  2628  			if cerr := conn.Close(); cerr != nil {
  2629  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2630  			}
  2631  		}()
  2632  	}()
  2633  
  2634  	return RegisterWatchHandler(ctx, mux, conn)
  2635  }
  2636  
  2637  // RegisterWatchHandler registers the http handlers for service Watch to "mux".
  2638  // The handlers forward requests to the grpc endpoint over "conn".
  2639  func RegisterWatchHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  2640  	return RegisterWatchHandlerClient(ctx, mux, etcdserverpb.NewWatchClient(conn))
  2641  }
  2642  
  2643  // etcdserverpb.RegisterWatchHandlerClient registers the http handlers for service Watch
  2644  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "WatchClient".
  2645  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "WatchClient"
  2646  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  2647  // "WatchClient" to call the correct interceptors.
  2648  func RegisterWatchHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.WatchClient) error {
  2649  
  2650  	mux.Handle("POST", pattern_Watch_Watch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2651  		ctx, cancel := context.WithCancel(req.Context())
  2652  		defer cancel()
  2653  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2654  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2655  		if err != nil {
  2656  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2657  			return
  2658  		}
  2659  		resp, md, err := request_Watch_Watch_0(rctx, inboundMarshaler, client, req, pathParams)
  2660  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2661  		if err != nil {
  2662  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2663  			return
  2664  		}
  2665  
  2666  		forward_Watch_Watch_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
  2667  
  2668  	})
  2669  
  2670  	return nil
  2671  }
  2672  
  2673  var (
  2674  	pattern_Watch_Watch_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v3", "watch"}, "", runtime.AssumeColonVerbOpt(true)))
  2675  )
  2676  
  2677  var (
  2678  	forward_Watch_Watch_0 = runtime.ForwardResponseStream
  2679  )
  2680  
  2681  // RegisterLeaseHandlerFromEndpoint is same as RegisterLeaseHandler but
  2682  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  2683  func RegisterLeaseHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  2684  	conn, err := grpc.Dial(endpoint, opts...)
  2685  	if err != nil {
  2686  		return err
  2687  	}
  2688  	defer func() {
  2689  		if err != nil {
  2690  			if cerr := conn.Close(); cerr != nil {
  2691  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2692  			}
  2693  			return
  2694  		}
  2695  		go func() {
  2696  			<-ctx.Done()
  2697  			if cerr := conn.Close(); cerr != nil {
  2698  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2699  			}
  2700  		}()
  2701  	}()
  2702  
  2703  	return RegisterLeaseHandler(ctx, mux, conn)
  2704  }
  2705  
  2706  // RegisterLeaseHandler registers the http handlers for service Lease to "mux".
  2707  // The handlers forward requests to the grpc endpoint over "conn".
  2708  func RegisterLeaseHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  2709  	return RegisterLeaseHandlerClient(ctx, mux, etcdserverpb.NewLeaseClient(conn))
  2710  }
  2711  
  2712  // etcdserverpb.RegisterLeaseHandlerClient registers the http handlers for service Lease
  2713  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LeaseClient".
  2714  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LeaseClient"
  2715  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  2716  // "LeaseClient" to call the correct interceptors.
  2717  func RegisterLeaseHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.LeaseClient) error {
  2718  
  2719  	mux.Handle("POST", pattern_Lease_LeaseGrant_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2720  		ctx, cancel := context.WithCancel(req.Context())
  2721  		defer cancel()
  2722  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2723  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2724  		if err != nil {
  2725  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2726  			return
  2727  		}
  2728  		resp, md, err := request_Lease_LeaseGrant_0(rctx, inboundMarshaler, client, req, pathParams)
  2729  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2730  		if err != nil {
  2731  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2732  			return
  2733  		}
  2734  
  2735  		forward_Lease_LeaseGrant_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2736  
  2737  	})
  2738  
  2739  	mux.Handle("POST", pattern_Lease_LeaseRevoke_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2740  		ctx, cancel := context.WithCancel(req.Context())
  2741  		defer cancel()
  2742  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2743  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2744  		if err != nil {
  2745  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2746  			return
  2747  		}
  2748  		resp, md, err := request_Lease_LeaseRevoke_0(rctx, inboundMarshaler, client, req, pathParams)
  2749  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2750  		if err != nil {
  2751  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2752  			return
  2753  		}
  2754  
  2755  		forward_Lease_LeaseRevoke_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2756  
  2757  	})
  2758  
  2759  	mux.Handle("POST", pattern_Lease_LeaseRevoke_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2760  		ctx, cancel := context.WithCancel(req.Context())
  2761  		defer cancel()
  2762  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2763  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2764  		if err != nil {
  2765  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2766  			return
  2767  		}
  2768  		resp, md, err := request_Lease_LeaseRevoke_1(rctx, inboundMarshaler, client, req, pathParams)
  2769  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2770  		if err != nil {
  2771  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2772  			return
  2773  		}
  2774  
  2775  		forward_Lease_LeaseRevoke_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2776  
  2777  	})
  2778  
  2779  	mux.Handle("POST", pattern_Lease_LeaseKeepAlive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2780  		ctx, cancel := context.WithCancel(req.Context())
  2781  		defer cancel()
  2782  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2783  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2784  		if err != nil {
  2785  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2786  			return
  2787  		}
  2788  		resp, md, err := request_Lease_LeaseKeepAlive_0(rctx, inboundMarshaler, client, req, pathParams)
  2789  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2790  		if err != nil {
  2791  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2792  			return
  2793  		}
  2794  
  2795  		forward_Lease_LeaseKeepAlive_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
  2796  
  2797  	})
  2798  
  2799  	mux.Handle("POST", pattern_Lease_LeaseTimeToLive_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2800  		ctx, cancel := context.WithCancel(req.Context())
  2801  		defer cancel()
  2802  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2803  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2804  		if err != nil {
  2805  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2806  			return
  2807  		}
  2808  		resp, md, err := request_Lease_LeaseTimeToLive_0(rctx, inboundMarshaler, client, req, pathParams)
  2809  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2810  		if err != nil {
  2811  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2812  			return
  2813  		}
  2814  
  2815  		forward_Lease_LeaseTimeToLive_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2816  
  2817  	})
  2818  
  2819  	mux.Handle("POST", pattern_Lease_LeaseTimeToLive_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2820  		ctx, cancel := context.WithCancel(req.Context())
  2821  		defer cancel()
  2822  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2823  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2824  		if err != nil {
  2825  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2826  			return
  2827  		}
  2828  		resp, md, err := request_Lease_LeaseTimeToLive_1(rctx, inboundMarshaler, client, req, pathParams)
  2829  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2830  		if err != nil {
  2831  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2832  			return
  2833  		}
  2834  
  2835  		forward_Lease_LeaseTimeToLive_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2836  
  2837  	})
  2838  
  2839  	mux.Handle("POST", pattern_Lease_LeaseLeases_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2840  		ctx, cancel := context.WithCancel(req.Context())
  2841  		defer cancel()
  2842  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2843  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2844  		if err != nil {
  2845  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2846  			return
  2847  		}
  2848  		resp, md, err := request_Lease_LeaseLeases_0(rctx, inboundMarshaler, client, req, pathParams)
  2849  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2850  		if err != nil {
  2851  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2852  			return
  2853  		}
  2854  
  2855  		forward_Lease_LeaseLeases_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2856  
  2857  	})
  2858  
  2859  	mux.Handle("POST", pattern_Lease_LeaseLeases_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2860  		ctx, cancel := context.WithCancel(req.Context())
  2861  		defer cancel()
  2862  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2863  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2864  		if err != nil {
  2865  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2866  			return
  2867  		}
  2868  		resp, md, err := request_Lease_LeaseLeases_1(rctx, inboundMarshaler, client, req, pathParams)
  2869  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2870  		if err != nil {
  2871  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2872  			return
  2873  		}
  2874  
  2875  		forward_Lease_LeaseLeases_1(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2876  
  2877  	})
  2878  
  2879  	return nil
  2880  }
  2881  
  2882  var (
  2883  	pattern_Lease_LeaseGrant_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "grant"}, "", runtime.AssumeColonVerbOpt(true)))
  2884  
  2885  	pattern_Lease_LeaseRevoke_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "revoke"}, "", runtime.AssumeColonVerbOpt(true)))
  2886  
  2887  	pattern_Lease_LeaseRevoke_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "kv", "lease", "revoke"}, "", runtime.AssumeColonVerbOpt(true)))
  2888  
  2889  	pattern_Lease_LeaseKeepAlive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "keepalive"}, "", runtime.AssumeColonVerbOpt(true)))
  2890  
  2891  	pattern_Lease_LeaseTimeToLive_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "timetolive"}, "", runtime.AssumeColonVerbOpt(true)))
  2892  
  2893  	pattern_Lease_LeaseTimeToLive_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "kv", "lease", "timetolive"}, "", runtime.AssumeColonVerbOpt(true)))
  2894  
  2895  	pattern_Lease_LeaseLeases_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lease", "leases"}, "", runtime.AssumeColonVerbOpt(true)))
  2896  
  2897  	pattern_Lease_LeaseLeases_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "kv", "lease", "leases"}, "", runtime.AssumeColonVerbOpt(true)))
  2898  )
  2899  
  2900  var (
  2901  	forward_Lease_LeaseGrant_0 = runtime.ForwardResponseMessage
  2902  
  2903  	forward_Lease_LeaseRevoke_0 = runtime.ForwardResponseMessage
  2904  
  2905  	forward_Lease_LeaseRevoke_1 = runtime.ForwardResponseMessage
  2906  
  2907  	forward_Lease_LeaseKeepAlive_0 = runtime.ForwardResponseStream
  2908  
  2909  	forward_Lease_LeaseTimeToLive_0 = runtime.ForwardResponseMessage
  2910  
  2911  	forward_Lease_LeaseTimeToLive_1 = runtime.ForwardResponseMessage
  2912  
  2913  	forward_Lease_LeaseLeases_0 = runtime.ForwardResponseMessage
  2914  
  2915  	forward_Lease_LeaseLeases_1 = runtime.ForwardResponseMessage
  2916  )
  2917  
  2918  // RegisterClusterHandlerFromEndpoint is same as RegisterClusterHandler but
  2919  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  2920  func RegisterClusterHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  2921  	conn, err := grpc.Dial(endpoint, opts...)
  2922  	if err != nil {
  2923  		return err
  2924  	}
  2925  	defer func() {
  2926  		if err != nil {
  2927  			if cerr := conn.Close(); cerr != nil {
  2928  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2929  			}
  2930  			return
  2931  		}
  2932  		go func() {
  2933  			<-ctx.Done()
  2934  			if cerr := conn.Close(); cerr != nil {
  2935  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  2936  			}
  2937  		}()
  2938  	}()
  2939  
  2940  	return RegisterClusterHandler(ctx, mux, conn)
  2941  }
  2942  
  2943  // RegisterClusterHandler registers the http handlers for service Cluster to "mux".
  2944  // The handlers forward requests to the grpc endpoint over "conn".
  2945  func RegisterClusterHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  2946  	return RegisterClusterHandlerClient(ctx, mux, etcdserverpb.NewClusterClient(conn))
  2947  }
  2948  
  2949  // etcdserverpb.RegisterClusterHandlerClient registers the http handlers for service Cluster
  2950  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ClusterClient".
  2951  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ClusterClient"
  2952  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  2953  // "ClusterClient" to call the correct interceptors.
  2954  func RegisterClusterHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.ClusterClient) error {
  2955  
  2956  	mux.Handle("POST", pattern_Cluster_MemberAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2957  		ctx, cancel := context.WithCancel(req.Context())
  2958  		defer cancel()
  2959  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2960  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2961  		if err != nil {
  2962  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2963  			return
  2964  		}
  2965  		resp, md, err := request_Cluster_MemberAdd_0(rctx, inboundMarshaler, client, req, pathParams)
  2966  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2967  		if err != nil {
  2968  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2969  			return
  2970  		}
  2971  
  2972  		forward_Cluster_MemberAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2973  
  2974  	})
  2975  
  2976  	mux.Handle("POST", pattern_Cluster_MemberRemove_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2977  		ctx, cancel := context.WithCancel(req.Context())
  2978  		defer cancel()
  2979  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  2980  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  2981  		if err != nil {
  2982  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2983  			return
  2984  		}
  2985  		resp, md, err := request_Cluster_MemberRemove_0(rctx, inboundMarshaler, client, req, pathParams)
  2986  		ctx = runtime.NewServerMetadataContext(ctx, md)
  2987  		if err != nil {
  2988  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  2989  			return
  2990  		}
  2991  
  2992  		forward_Cluster_MemberRemove_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  2993  
  2994  	})
  2995  
  2996  	mux.Handle("POST", pattern_Cluster_MemberUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  2997  		ctx, cancel := context.WithCancel(req.Context())
  2998  		defer cancel()
  2999  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3000  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3001  		if err != nil {
  3002  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3003  			return
  3004  		}
  3005  		resp, md, err := request_Cluster_MemberUpdate_0(rctx, inboundMarshaler, client, req, pathParams)
  3006  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3007  		if err != nil {
  3008  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3009  			return
  3010  		}
  3011  
  3012  		forward_Cluster_MemberUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3013  
  3014  	})
  3015  
  3016  	mux.Handle("POST", pattern_Cluster_MemberList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3017  		ctx, cancel := context.WithCancel(req.Context())
  3018  		defer cancel()
  3019  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3020  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3021  		if err != nil {
  3022  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3023  			return
  3024  		}
  3025  		resp, md, err := request_Cluster_MemberList_0(rctx, inboundMarshaler, client, req, pathParams)
  3026  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3027  		if err != nil {
  3028  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3029  			return
  3030  		}
  3031  
  3032  		forward_Cluster_MemberList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3033  
  3034  	})
  3035  
  3036  	mux.Handle("POST", pattern_Cluster_MemberPromote_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3037  		ctx, cancel := context.WithCancel(req.Context())
  3038  		defer cancel()
  3039  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3040  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3041  		if err != nil {
  3042  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3043  			return
  3044  		}
  3045  		resp, md, err := request_Cluster_MemberPromote_0(rctx, inboundMarshaler, client, req, pathParams)
  3046  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3047  		if err != nil {
  3048  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3049  			return
  3050  		}
  3051  
  3052  		forward_Cluster_MemberPromote_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3053  
  3054  	})
  3055  
  3056  	return nil
  3057  }
  3058  
  3059  var (
  3060  	pattern_Cluster_MemberAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "add"}, "", runtime.AssumeColonVerbOpt(true)))
  3061  
  3062  	pattern_Cluster_MemberRemove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "remove"}, "", runtime.AssumeColonVerbOpt(true)))
  3063  
  3064  	pattern_Cluster_MemberUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "update"}, "", runtime.AssumeColonVerbOpt(true)))
  3065  
  3066  	pattern_Cluster_MemberList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "list"}, "", runtime.AssumeColonVerbOpt(true)))
  3067  
  3068  	pattern_Cluster_MemberPromote_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "cluster", "member", "promote"}, "", runtime.AssumeColonVerbOpt(true)))
  3069  )
  3070  
  3071  var (
  3072  	forward_Cluster_MemberAdd_0 = runtime.ForwardResponseMessage
  3073  
  3074  	forward_Cluster_MemberRemove_0 = runtime.ForwardResponseMessage
  3075  
  3076  	forward_Cluster_MemberUpdate_0 = runtime.ForwardResponseMessage
  3077  
  3078  	forward_Cluster_MemberList_0 = runtime.ForwardResponseMessage
  3079  
  3080  	forward_Cluster_MemberPromote_0 = runtime.ForwardResponseMessage
  3081  )
  3082  
  3083  // RegisterMaintenanceHandlerFromEndpoint is same as RegisterMaintenanceHandler but
  3084  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  3085  func RegisterMaintenanceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  3086  	conn, err := grpc.Dial(endpoint, opts...)
  3087  	if err != nil {
  3088  		return err
  3089  	}
  3090  	defer func() {
  3091  		if err != nil {
  3092  			if cerr := conn.Close(); cerr != nil {
  3093  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  3094  			}
  3095  			return
  3096  		}
  3097  		go func() {
  3098  			<-ctx.Done()
  3099  			if cerr := conn.Close(); cerr != nil {
  3100  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  3101  			}
  3102  		}()
  3103  	}()
  3104  
  3105  	return RegisterMaintenanceHandler(ctx, mux, conn)
  3106  }
  3107  
  3108  // RegisterMaintenanceHandler registers the http handlers for service Maintenance to "mux".
  3109  // The handlers forward requests to the grpc endpoint over "conn".
  3110  func RegisterMaintenanceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  3111  	return RegisterMaintenanceHandlerClient(ctx, mux, etcdserverpb.NewMaintenanceClient(conn))
  3112  }
  3113  
  3114  // etcdserverpb.RegisterMaintenanceHandlerClient registers the http handlers for service Maintenance
  3115  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MaintenanceClient".
  3116  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MaintenanceClient"
  3117  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  3118  // "MaintenanceClient" to call the correct interceptors.
  3119  func RegisterMaintenanceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.MaintenanceClient) error {
  3120  
  3121  	mux.Handle("POST", pattern_Maintenance_Alarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3122  		ctx, cancel := context.WithCancel(req.Context())
  3123  		defer cancel()
  3124  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3125  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3126  		if err != nil {
  3127  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3128  			return
  3129  		}
  3130  		resp, md, err := request_Maintenance_Alarm_0(rctx, inboundMarshaler, client, req, pathParams)
  3131  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3132  		if err != nil {
  3133  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3134  			return
  3135  		}
  3136  
  3137  		forward_Maintenance_Alarm_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3138  
  3139  	})
  3140  
  3141  	mux.Handle("POST", pattern_Maintenance_Status_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3142  		ctx, cancel := context.WithCancel(req.Context())
  3143  		defer cancel()
  3144  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3145  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3146  		if err != nil {
  3147  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3148  			return
  3149  		}
  3150  		resp, md, err := request_Maintenance_Status_0(rctx, inboundMarshaler, client, req, pathParams)
  3151  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3152  		if err != nil {
  3153  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3154  			return
  3155  		}
  3156  
  3157  		forward_Maintenance_Status_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3158  
  3159  	})
  3160  
  3161  	mux.Handle("POST", pattern_Maintenance_Defragment_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3162  		ctx, cancel := context.WithCancel(req.Context())
  3163  		defer cancel()
  3164  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3165  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3166  		if err != nil {
  3167  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3168  			return
  3169  		}
  3170  		resp, md, err := request_Maintenance_Defragment_0(rctx, inboundMarshaler, client, req, pathParams)
  3171  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3172  		if err != nil {
  3173  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3174  			return
  3175  		}
  3176  
  3177  		forward_Maintenance_Defragment_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3178  
  3179  	})
  3180  
  3181  	mux.Handle("POST", pattern_Maintenance_Hash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3182  		ctx, cancel := context.WithCancel(req.Context())
  3183  		defer cancel()
  3184  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3185  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3186  		if err != nil {
  3187  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3188  			return
  3189  		}
  3190  		resp, md, err := request_Maintenance_Hash_0(rctx, inboundMarshaler, client, req, pathParams)
  3191  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3192  		if err != nil {
  3193  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3194  			return
  3195  		}
  3196  
  3197  		forward_Maintenance_Hash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3198  
  3199  	})
  3200  
  3201  	mux.Handle("POST", pattern_Maintenance_HashKV_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3202  		ctx, cancel := context.WithCancel(req.Context())
  3203  		defer cancel()
  3204  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3205  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3206  		if err != nil {
  3207  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3208  			return
  3209  		}
  3210  		resp, md, err := request_Maintenance_HashKV_0(rctx, inboundMarshaler, client, req, pathParams)
  3211  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3212  		if err != nil {
  3213  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3214  			return
  3215  		}
  3216  
  3217  		forward_Maintenance_HashKV_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3218  
  3219  	})
  3220  
  3221  	mux.Handle("POST", pattern_Maintenance_Snapshot_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3222  		ctx, cancel := context.WithCancel(req.Context())
  3223  		defer cancel()
  3224  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3225  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3226  		if err != nil {
  3227  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3228  			return
  3229  		}
  3230  		resp, md, err := request_Maintenance_Snapshot_0(rctx, inboundMarshaler, client, req, pathParams)
  3231  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3232  		if err != nil {
  3233  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3234  			return
  3235  		}
  3236  
  3237  		forward_Maintenance_Snapshot_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
  3238  
  3239  	})
  3240  
  3241  	mux.Handle("POST", pattern_Maintenance_MoveLeader_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3242  		ctx, cancel := context.WithCancel(req.Context())
  3243  		defer cancel()
  3244  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3245  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3246  		if err != nil {
  3247  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3248  			return
  3249  		}
  3250  		resp, md, err := request_Maintenance_MoveLeader_0(rctx, inboundMarshaler, client, req, pathParams)
  3251  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3252  		if err != nil {
  3253  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3254  			return
  3255  		}
  3256  
  3257  		forward_Maintenance_MoveLeader_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3258  
  3259  	})
  3260  
  3261  	mux.Handle("POST", pattern_Maintenance_Downgrade_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3262  		ctx, cancel := context.WithCancel(req.Context())
  3263  		defer cancel()
  3264  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3265  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3266  		if err != nil {
  3267  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3268  			return
  3269  		}
  3270  		resp, md, err := request_Maintenance_Downgrade_0(rctx, inboundMarshaler, client, req, pathParams)
  3271  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3272  		if err != nil {
  3273  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3274  			return
  3275  		}
  3276  
  3277  		forward_Maintenance_Downgrade_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3278  
  3279  	})
  3280  
  3281  	return nil
  3282  }
  3283  
  3284  var (
  3285  	pattern_Maintenance_Alarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "alarm"}, "", runtime.AssumeColonVerbOpt(true)))
  3286  
  3287  	pattern_Maintenance_Status_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "status"}, "", runtime.AssumeColonVerbOpt(true)))
  3288  
  3289  	pattern_Maintenance_Defragment_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "defragment"}, "", runtime.AssumeColonVerbOpt(true)))
  3290  
  3291  	pattern_Maintenance_Hash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "hash"}, "", runtime.AssumeColonVerbOpt(true)))
  3292  
  3293  	pattern_Maintenance_HashKV_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "hashkv"}, "", runtime.AssumeColonVerbOpt(true)))
  3294  
  3295  	pattern_Maintenance_Snapshot_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "snapshot"}, "", runtime.AssumeColonVerbOpt(true)))
  3296  
  3297  	pattern_Maintenance_MoveLeader_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "transfer-leadership"}, "", runtime.AssumeColonVerbOpt(true)))
  3298  
  3299  	pattern_Maintenance_Downgrade_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "maintenance", "downgrade"}, "", runtime.AssumeColonVerbOpt(true)))
  3300  )
  3301  
  3302  var (
  3303  	forward_Maintenance_Alarm_0 = runtime.ForwardResponseMessage
  3304  
  3305  	forward_Maintenance_Status_0 = runtime.ForwardResponseMessage
  3306  
  3307  	forward_Maintenance_Defragment_0 = runtime.ForwardResponseMessage
  3308  
  3309  	forward_Maintenance_Hash_0 = runtime.ForwardResponseMessage
  3310  
  3311  	forward_Maintenance_HashKV_0 = runtime.ForwardResponseMessage
  3312  
  3313  	forward_Maintenance_Snapshot_0 = runtime.ForwardResponseStream
  3314  
  3315  	forward_Maintenance_MoveLeader_0 = runtime.ForwardResponseMessage
  3316  
  3317  	forward_Maintenance_Downgrade_0 = runtime.ForwardResponseMessage
  3318  )
  3319  
  3320  // RegisterAuthHandlerFromEndpoint is same as RegisterAuthHandler but
  3321  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  3322  func RegisterAuthHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  3323  	conn, err := grpc.Dial(endpoint, opts...)
  3324  	if err != nil {
  3325  		return err
  3326  	}
  3327  	defer func() {
  3328  		if err != nil {
  3329  			if cerr := conn.Close(); cerr != nil {
  3330  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  3331  			}
  3332  			return
  3333  		}
  3334  		go func() {
  3335  			<-ctx.Done()
  3336  			if cerr := conn.Close(); cerr != nil {
  3337  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  3338  			}
  3339  		}()
  3340  	}()
  3341  
  3342  	return RegisterAuthHandler(ctx, mux, conn)
  3343  }
  3344  
  3345  // RegisterAuthHandler registers the http handlers for service Auth to "mux".
  3346  // The handlers forward requests to the grpc endpoint over "conn".
  3347  func RegisterAuthHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
  3348  	return RegisterAuthHandlerClient(ctx, mux, etcdserverpb.NewAuthClient(conn))
  3349  }
  3350  
  3351  // etcdserverpb.RegisterAuthHandlerClient registers the http handlers for service Auth
  3352  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AuthClient".
  3353  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AuthClient"
  3354  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
  3355  // "AuthClient" to call the correct interceptors.
  3356  func RegisterAuthHandlerClient(ctx context.Context, mux *runtime.ServeMux, client etcdserverpb.AuthClient) error {
  3357  
  3358  	mux.Handle("POST", pattern_Auth_AuthEnable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3359  		ctx, cancel := context.WithCancel(req.Context())
  3360  		defer cancel()
  3361  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3362  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3363  		if err != nil {
  3364  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3365  			return
  3366  		}
  3367  		resp, md, err := request_Auth_AuthEnable_0(rctx, inboundMarshaler, client, req, pathParams)
  3368  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3369  		if err != nil {
  3370  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3371  			return
  3372  		}
  3373  
  3374  		forward_Auth_AuthEnable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3375  
  3376  	})
  3377  
  3378  	mux.Handle("POST", pattern_Auth_AuthDisable_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3379  		ctx, cancel := context.WithCancel(req.Context())
  3380  		defer cancel()
  3381  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3382  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3383  		if err != nil {
  3384  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3385  			return
  3386  		}
  3387  		resp, md, err := request_Auth_AuthDisable_0(rctx, inboundMarshaler, client, req, pathParams)
  3388  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3389  		if err != nil {
  3390  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3391  			return
  3392  		}
  3393  
  3394  		forward_Auth_AuthDisable_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3395  
  3396  	})
  3397  
  3398  	mux.Handle("POST", pattern_Auth_AuthStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3399  		ctx, cancel := context.WithCancel(req.Context())
  3400  		defer cancel()
  3401  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3402  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3403  		if err != nil {
  3404  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3405  			return
  3406  		}
  3407  		resp, md, err := request_Auth_AuthStatus_0(rctx, inboundMarshaler, client, req, pathParams)
  3408  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3409  		if err != nil {
  3410  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3411  			return
  3412  		}
  3413  
  3414  		forward_Auth_AuthStatus_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3415  
  3416  	})
  3417  
  3418  	mux.Handle("POST", pattern_Auth_Authenticate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3419  		ctx, cancel := context.WithCancel(req.Context())
  3420  		defer cancel()
  3421  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3422  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3423  		if err != nil {
  3424  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3425  			return
  3426  		}
  3427  		resp, md, err := request_Auth_Authenticate_0(rctx, inboundMarshaler, client, req, pathParams)
  3428  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3429  		if err != nil {
  3430  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3431  			return
  3432  		}
  3433  
  3434  		forward_Auth_Authenticate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3435  
  3436  	})
  3437  
  3438  	mux.Handle("POST", pattern_Auth_UserAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3439  		ctx, cancel := context.WithCancel(req.Context())
  3440  		defer cancel()
  3441  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3442  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3443  		if err != nil {
  3444  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3445  			return
  3446  		}
  3447  		resp, md, err := request_Auth_UserAdd_0(rctx, inboundMarshaler, client, req, pathParams)
  3448  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3449  		if err != nil {
  3450  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3451  			return
  3452  		}
  3453  
  3454  		forward_Auth_UserAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3455  
  3456  	})
  3457  
  3458  	mux.Handle("POST", pattern_Auth_UserGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3459  		ctx, cancel := context.WithCancel(req.Context())
  3460  		defer cancel()
  3461  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3462  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3463  		if err != nil {
  3464  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3465  			return
  3466  		}
  3467  		resp, md, err := request_Auth_UserGet_0(rctx, inboundMarshaler, client, req, pathParams)
  3468  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3469  		if err != nil {
  3470  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3471  			return
  3472  		}
  3473  
  3474  		forward_Auth_UserGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3475  
  3476  	})
  3477  
  3478  	mux.Handle("POST", pattern_Auth_UserList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3479  		ctx, cancel := context.WithCancel(req.Context())
  3480  		defer cancel()
  3481  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3482  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3483  		if err != nil {
  3484  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3485  			return
  3486  		}
  3487  		resp, md, err := request_Auth_UserList_0(rctx, inboundMarshaler, client, req, pathParams)
  3488  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3489  		if err != nil {
  3490  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3491  			return
  3492  		}
  3493  
  3494  		forward_Auth_UserList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3495  
  3496  	})
  3497  
  3498  	mux.Handle("POST", pattern_Auth_UserDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3499  		ctx, cancel := context.WithCancel(req.Context())
  3500  		defer cancel()
  3501  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3502  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3503  		if err != nil {
  3504  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3505  			return
  3506  		}
  3507  		resp, md, err := request_Auth_UserDelete_0(rctx, inboundMarshaler, client, req, pathParams)
  3508  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3509  		if err != nil {
  3510  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3511  			return
  3512  		}
  3513  
  3514  		forward_Auth_UserDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3515  
  3516  	})
  3517  
  3518  	mux.Handle("POST", pattern_Auth_UserChangePassword_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3519  		ctx, cancel := context.WithCancel(req.Context())
  3520  		defer cancel()
  3521  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3522  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3523  		if err != nil {
  3524  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3525  			return
  3526  		}
  3527  		resp, md, err := request_Auth_UserChangePassword_0(rctx, inboundMarshaler, client, req, pathParams)
  3528  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3529  		if err != nil {
  3530  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3531  			return
  3532  		}
  3533  
  3534  		forward_Auth_UserChangePassword_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3535  
  3536  	})
  3537  
  3538  	mux.Handle("POST", pattern_Auth_UserGrantRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3539  		ctx, cancel := context.WithCancel(req.Context())
  3540  		defer cancel()
  3541  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3542  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3543  		if err != nil {
  3544  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3545  			return
  3546  		}
  3547  		resp, md, err := request_Auth_UserGrantRole_0(rctx, inboundMarshaler, client, req, pathParams)
  3548  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3549  		if err != nil {
  3550  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3551  			return
  3552  		}
  3553  
  3554  		forward_Auth_UserGrantRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3555  
  3556  	})
  3557  
  3558  	mux.Handle("POST", pattern_Auth_UserRevokeRole_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3559  		ctx, cancel := context.WithCancel(req.Context())
  3560  		defer cancel()
  3561  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3562  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3563  		if err != nil {
  3564  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3565  			return
  3566  		}
  3567  		resp, md, err := request_Auth_UserRevokeRole_0(rctx, inboundMarshaler, client, req, pathParams)
  3568  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3569  		if err != nil {
  3570  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3571  			return
  3572  		}
  3573  
  3574  		forward_Auth_UserRevokeRole_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3575  
  3576  	})
  3577  
  3578  	mux.Handle("POST", pattern_Auth_RoleAdd_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3579  		ctx, cancel := context.WithCancel(req.Context())
  3580  		defer cancel()
  3581  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3582  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3583  		if err != nil {
  3584  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3585  			return
  3586  		}
  3587  		resp, md, err := request_Auth_RoleAdd_0(rctx, inboundMarshaler, client, req, pathParams)
  3588  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3589  		if err != nil {
  3590  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3591  			return
  3592  		}
  3593  
  3594  		forward_Auth_RoleAdd_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3595  
  3596  	})
  3597  
  3598  	mux.Handle("POST", pattern_Auth_RoleGet_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3599  		ctx, cancel := context.WithCancel(req.Context())
  3600  		defer cancel()
  3601  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3602  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3603  		if err != nil {
  3604  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3605  			return
  3606  		}
  3607  		resp, md, err := request_Auth_RoleGet_0(rctx, inboundMarshaler, client, req, pathParams)
  3608  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3609  		if err != nil {
  3610  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3611  			return
  3612  		}
  3613  
  3614  		forward_Auth_RoleGet_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3615  
  3616  	})
  3617  
  3618  	mux.Handle("POST", pattern_Auth_RoleList_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3619  		ctx, cancel := context.WithCancel(req.Context())
  3620  		defer cancel()
  3621  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3622  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3623  		if err != nil {
  3624  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3625  			return
  3626  		}
  3627  		resp, md, err := request_Auth_RoleList_0(rctx, inboundMarshaler, client, req, pathParams)
  3628  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3629  		if err != nil {
  3630  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3631  			return
  3632  		}
  3633  
  3634  		forward_Auth_RoleList_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3635  
  3636  	})
  3637  
  3638  	mux.Handle("POST", pattern_Auth_RoleDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3639  		ctx, cancel := context.WithCancel(req.Context())
  3640  		defer cancel()
  3641  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3642  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3643  		if err != nil {
  3644  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3645  			return
  3646  		}
  3647  		resp, md, err := request_Auth_RoleDelete_0(rctx, inboundMarshaler, client, req, pathParams)
  3648  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3649  		if err != nil {
  3650  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3651  			return
  3652  		}
  3653  
  3654  		forward_Auth_RoleDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3655  
  3656  	})
  3657  
  3658  	mux.Handle("POST", pattern_Auth_RoleGrantPermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3659  		ctx, cancel := context.WithCancel(req.Context())
  3660  		defer cancel()
  3661  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3662  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3663  		if err != nil {
  3664  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3665  			return
  3666  		}
  3667  		resp, md, err := request_Auth_RoleGrantPermission_0(rctx, inboundMarshaler, client, req, pathParams)
  3668  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3669  		if err != nil {
  3670  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3671  			return
  3672  		}
  3673  
  3674  		forward_Auth_RoleGrantPermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3675  
  3676  	})
  3677  
  3678  	mux.Handle("POST", pattern_Auth_RoleRevokePermission_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
  3679  		ctx, cancel := context.WithCancel(req.Context())
  3680  		defer cancel()
  3681  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
  3682  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
  3683  		if err != nil {
  3684  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3685  			return
  3686  		}
  3687  		resp, md, err := request_Auth_RoleRevokePermission_0(rctx, inboundMarshaler, client, req, pathParams)
  3688  		ctx = runtime.NewServerMetadataContext(ctx, md)
  3689  		if err != nil {
  3690  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
  3691  			return
  3692  		}
  3693  
  3694  		forward_Auth_RoleRevokePermission_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
  3695  
  3696  	})
  3697  
  3698  	return nil
  3699  }
  3700  
  3701  var (
  3702  	pattern_Auth_AuthEnable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "auth", "enable"}, "", runtime.AssumeColonVerbOpt(true)))
  3703  
  3704  	pattern_Auth_AuthDisable_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "auth", "disable"}, "", runtime.AssumeColonVerbOpt(true)))
  3705  
  3706  	pattern_Auth_AuthStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "auth", "status"}, "", runtime.AssumeColonVerbOpt(true)))
  3707  
  3708  	pattern_Auth_Authenticate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "auth", "authenticate"}, "", runtime.AssumeColonVerbOpt(true)))
  3709  
  3710  	pattern_Auth_UserAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "add"}, "", runtime.AssumeColonVerbOpt(true)))
  3711  
  3712  	pattern_Auth_UserGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "get"}, "", runtime.AssumeColonVerbOpt(true)))
  3713  
  3714  	pattern_Auth_UserList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "list"}, "", runtime.AssumeColonVerbOpt(true)))
  3715  
  3716  	pattern_Auth_UserDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "delete"}, "", runtime.AssumeColonVerbOpt(true)))
  3717  
  3718  	pattern_Auth_UserChangePassword_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "changepw"}, "", runtime.AssumeColonVerbOpt(true)))
  3719  
  3720  	pattern_Auth_UserGrantRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "grant"}, "", runtime.AssumeColonVerbOpt(true)))
  3721  
  3722  	pattern_Auth_UserRevokeRole_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "user", "revoke"}, "", runtime.AssumeColonVerbOpt(true)))
  3723  
  3724  	pattern_Auth_RoleAdd_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "add"}, "", runtime.AssumeColonVerbOpt(true)))
  3725  
  3726  	pattern_Auth_RoleGet_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "get"}, "", runtime.AssumeColonVerbOpt(true)))
  3727  
  3728  	pattern_Auth_RoleList_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "list"}, "", runtime.AssumeColonVerbOpt(true)))
  3729  
  3730  	pattern_Auth_RoleDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "delete"}, "", runtime.AssumeColonVerbOpt(true)))
  3731  
  3732  	pattern_Auth_RoleGrantPermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "grant"}, "", runtime.AssumeColonVerbOpt(true)))
  3733  
  3734  	pattern_Auth_RoleRevokePermission_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v3", "auth", "role", "revoke"}, "", runtime.AssumeColonVerbOpt(true)))
  3735  )
  3736  
  3737  var (
  3738  	forward_Auth_AuthEnable_0 = runtime.ForwardResponseMessage
  3739  
  3740  	forward_Auth_AuthDisable_0 = runtime.ForwardResponseMessage
  3741  
  3742  	forward_Auth_AuthStatus_0 = runtime.ForwardResponseMessage
  3743  
  3744  	forward_Auth_Authenticate_0 = runtime.ForwardResponseMessage
  3745  
  3746  	forward_Auth_UserAdd_0 = runtime.ForwardResponseMessage
  3747  
  3748  	forward_Auth_UserGet_0 = runtime.ForwardResponseMessage
  3749  
  3750  	forward_Auth_UserList_0 = runtime.ForwardResponseMessage
  3751  
  3752  	forward_Auth_UserDelete_0 = runtime.ForwardResponseMessage
  3753  
  3754  	forward_Auth_UserChangePassword_0 = runtime.ForwardResponseMessage
  3755  
  3756  	forward_Auth_UserGrantRole_0 = runtime.ForwardResponseMessage
  3757  
  3758  	forward_Auth_UserRevokeRole_0 = runtime.ForwardResponseMessage
  3759  
  3760  	forward_Auth_RoleAdd_0 = runtime.ForwardResponseMessage
  3761  
  3762  	forward_Auth_RoleGet_0 = runtime.ForwardResponseMessage
  3763  
  3764  	forward_Auth_RoleList_0 = runtime.ForwardResponseMessage
  3765  
  3766  	forward_Auth_RoleDelete_0 = runtime.ForwardResponseMessage
  3767  
  3768  	forward_Auth_RoleGrantPermission_0 = runtime.ForwardResponseMessage
  3769  
  3770  	forward_Auth_RoleRevokePermission_0 = runtime.ForwardResponseMessage
  3771  )
  3772  

View as plain text