v3lock.pb.gw.go

Documentation: go.etcd.io/etcd/server/v3/etcdserver/api/v3lock/v3lockpb/gw

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: server/etcdserver/api/v3lock/v3lockpb/v3lock.proto
     3  
     4  /*
     5  Package v3lockpb 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/server/v3/etcdserver/api/v3lock/v3lockpb"
    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_Lock_Lock_0(ctx context.Context, marshaler runtime.Marshaler, client v3lockpb.LockClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    36  	var protoReq v3lockpb.LockRequest
    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.Lock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    48  	return msg, metadata, err
    49  
    50  }
    51  
    52  func local_request_Lock_Lock_0(ctx context.Context, marshaler runtime.Marshaler, server v3lockpb.LockServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    53  	var protoReq v3lockpb.LockRequest
    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.Lock(ctx, &protoReq)
    65  	return msg, metadata, err
    66  
    67  }
    68  
    69  func request_Lock_Unlock_0(ctx context.Context, marshaler runtime.Marshaler, client v3lockpb.LockClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    70  	var protoReq v3lockpb.UnlockRequest
    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.Unlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    82  	return msg, metadata, err
    83  
    84  }
    85  
    86  func local_request_Lock_Unlock_0(ctx context.Context, marshaler runtime.Marshaler, server v3lockpb.LockServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    87  	var protoReq v3lockpb.UnlockRequest
    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.Unlock(ctx, &protoReq)
    99  	return msg, metadata, err
   100  
   101  }
   102  
   103  // v3lockpb.RegisterLockHandlerServer registers the http handlers for service Lock to "mux".
   104  // UnaryRPC     :call v3lockpb.LockServer directly.
   105  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   106  func RegisterLockHandlerServer(ctx context.Context, mux *runtime.ServeMux, server v3lockpb.LockServer) error {
   107  
   108  	mux.Handle("POST", pattern_Lock_Lock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   109  		ctx, cancel := context.WithCancel(req.Context())
   110  		defer cancel()
   111  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   112  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   113  		if err != nil {
   114  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   115  			return
   116  		}
   117  		resp, md, err := local_request_Lock_Lock_0(rctx, inboundMarshaler, server, req, pathParams)
   118  		ctx = runtime.NewServerMetadataContext(ctx, md)
   119  		if err != nil {
   120  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   121  			return
   122  		}
   123  
   124  		forward_Lock_Lock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   125  
   126  	})
   127  
   128  	mux.Handle("POST", pattern_Lock_Unlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   129  		ctx, cancel := context.WithCancel(req.Context())
   130  		defer cancel()
   131  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   132  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   133  		if err != nil {
   134  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   135  			return
   136  		}
   137  		resp, md, err := local_request_Lock_Unlock_0(rctx, inboundMarshaler, server, req, pathParams)
   138  		ctx = runtime.NewServerMetadataContext(ctx, md)
   139  		if err != nil {
   140  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   141  			return
   142  		}
   143  
   144  		forward_Lock_Unlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   145  
   146  	})
   147  
   148  	return nil
   149  }
   150  
   151  // RegisterLockHandlerFromEndpoint is same as RegisterLockHandler but
   152  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   153  func RegisterLockHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   154  	conn, err := grpc.Dial(endpoint, opts...)
   155  	if err != nil {
   156  		return err
   157  	}
   158  	defer func() {
   159  		if err != nil {
   160  			if cerr := conn.Close(); cerr != nil {
   161  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   162  			}
   163  			return
   164  		}
   165  		go func() {
   166  			<-ctx.Done()
   167  			if cerr := conn.Close(); cerr != nil {
   168  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   169  			}
   170  		}()
   171  	}()
   172  
   173  	return RegisterLockHandler(ctx, mux, conn)
   174  }
   175  
   176  // RegisterLockHandler registers the http handlers for service Lock to "mux".
   177  // The handlers forward requests to the grpc endpoint over "conn".
   178  func RegisterLockHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
   179  	return RegisterLockHandlerClient(ctx, mux, v3lockpb.NewLockClient(conn))
   180  }
   181  
   182  // v3lockpb.RegisterLockHandlerClient registers the http handlers for service Lock
   183  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LockClient".
   184  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LockClient"
   185  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
   186  // "LockClient" to call the correct interceptors.
   187  func RegisterLockHandlerClient(ctx context.Context, mux *runtime.ServeMux, client v3lockpb.LockClient) error {
   188  
   189  	mux.Handle("POST", pattern_Lock_Lock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   190  		ctx, cancel := context.WithCancel(req.Context())
   191  		defer cancel()
   192  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   193  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   194  		if err != nil {
   195  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   196  			return
   197  		}
   198  		resp, md, err := request_Lock_Lock_0(rctx, inboundMarshaler, client, req, pathParams)
   199  		ctx = runtime.NewServerMetadataContext(ctx, md)
   200  		if err != nil {
   201  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   202  			return
   203  		}
   204  
   205  		forward_Lock_Lock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   206  
   207  	})
   208  
   209  	mux.Handle("POST", pattern_Lock_Unlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   210  		ctx, cancel := context.WithCancel(req.Context())
   211  		defer cancel()
   212  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   213  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   214  		if err != nil {
   215  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   216  			return
   217  		}
   218  		resp, md, err := request_Lock_Unlock_0(rctx, inboundMarshaler, client, req, pathParams)
   219  		ctx = runtime.NewServerMetadataContext(ctx, md)
   220  		if err != nil {
   221  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   222  			return
   223  		}
   224  
   225  		forward_Lock_Unlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   226  
   227  	})
   228  
   229  	return nil
   230  }
   231  
   232  var (
   233  	pattern_Lock_Lock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1}, []string{"v3", "lock"}, "", runtime.AssumeColonVerbOpt(true)))
   234  
   235  	pattern_Lock_Unlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v3", "lock", "unlock"}, "", runtime.AssumeColonVerbOpt(true)))
   236  )
   237  
   238  var (
   239  	forward_Lock_Lock_0 = runtime.ForwardResponseMessage
   240  
   241  	forward_Lock_Unlock_0 = runtime.ForwardResponseMessage
   242  )
   243
View as plain text