generate_unbound_methods.pb.gw.go

Documentation: github.com/grpc-ecosystem/grpc-gateway/examples/internal/proto/examplepb

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: examples/internal/proto/examplepb/generate_unbound_methods.proto
     3  
     4  /*
     5  Package examplepb is a reverse proxy.
     6  
     7  It translates gRPC into RESTful JSON APIs.
     8  */
     9  package examplepb
    10  
    11  import (
    12  	"context"
    13  	"io"
    14  	"net/http"
    15  
    16  	"github.com/golang/protobuf/descriptor"
    17  	"github.com/golang/protobuf/proto"
    18  	"github.com/grpc-ecosystem/grpc-gateway/runtime"
    19  	"github.com/grpc-ecosystem/grpc-gateway/utilities"
    20  	"google.golang.org/grpc"
    21  	"google.golang.org/grpc/codes"
    22  	"google.golang.org/grpc/grpclog"
    23  	"google.golang.org/grpc/metadata"
    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  var _ = metadata.Join
    35  
    36  func request_GenerateUnboundMethodsEchoService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, client GenerateUnboundMethodsEchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    37  	var protoReq GenerateUnboundMethodsSimpleMessage
    38  	var metadata runtime.ServerMetadata
    39  
    40  	newReader, berr := utilities.IOReaderFactory(req.Body)
    41  	if berr != nil {
    42  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    43  	}
    44  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    45  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    46  	}
    47  
    48  	msg, err := client.Echo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    49  	return msg, metadata, err
    50  
    51  }
    52  
    53  func local_request_GenerateUnboundMethodsEchoService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, server GenerateUnboundMethodsEchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    54  	var protoReq GenerateUnboundMethodsSimpleMessage
    55  	var metadata runtime.ServerMetadata
    56  
    57  	newReader, berr := utilities.IOReaderFactory(req.Body)
    58  	if berr != nil {
    59  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    60  	}
    61  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    62  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    63  	}
    64  
    65  	msg, err := server.Echo(ctx, &protoReq)
    66  	return msg, metadata, err
    67  
    68  }
    69  
    70  func request_GenerateUnboundMethodsEchoService_EchoBody_0(ctx context.Context, marshaler runtime.Marshaler, client GenerateUnboundMethodsEchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    71  	var protoReq GenerateUnboundMethodsSimpleMessage
    72  	var metadata runtime.ServerMetadata
    73  
    74  	newReader, berr := utilities.IOReaderFactory(req.Body)
    75  	if berr != nil {
    76  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    77  	}
    78  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    79  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    80  	}
    81  
    82  	msg, err := client.EchoBody(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    83  	return msg, metadata, err
    84  
    85  }
    86  
    87  func local_request_GenerateUnboundMethodsEchoService_EchoBody_0(ctx context.Context, marshaler runtime.Marshaler, server GenerateUnboundMethodsEchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    88  	var protoReq GenerateUnboundMethodsSimpleMessage
    89  	var metadata runtime.ServerMetadata
    90  
    91  	newReader, berr := utilities.IOReaderFactory(req.Body)
    92  	if berr != nil {
    93  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
    94  	}
    95  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
    96  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    97  	}
    98  
    99  	msg, err := server.EchoBody(ctx, &protoReq)
   100  	return msg, metadata, err
   101  
   102  }
   103  
   104  func request_GenerateUnboundMethodsEchoService_EchoDelete_0(ctx context.Context, marshaler runtime.Marshaler, client GenerateUnboundMethodsEchoServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   105  	var protoReq GenerateUnboundMethodsSimpleMessage
   106  	var metadata runtime.ServerMetadata
   107  
   108  	newReader, berr := utilities.IOReaderFactory(req.Body)
   109  	if berr != nil {
   110  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   111  	}
   112  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   113  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   114  	}
   115  
   116  	msg, err := client.EchoDelete(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
   117  	return msg, metadata, err
   118  
   119  }
   120  
   121  func local_request_GenerateUnboundMethodsEchoService_EchoDelete_0(ctx context.Context, marshaler runtime.Marshaler, server GenerateUnboundMethodsEchoServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
   122  	var protoReq GenerateUnboundMethodsSimpleMessage
   123  	var metadata runtime.ServerMetadata
   124  
   125  	newReader, berr := utilities.IOReaderFactory(req.Body)
   126  	if berr != nil {
   127  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
   128  	}
   129  	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
   130  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
   131  	}
   132  
   133  	msg, err := server.EchoDelete(ctx, &protoReq)
   134  	return msg, metadata, err
   135  
   136  }
   137  
   138  // RegisterGenerateUnboundMethodsEchoServiceHandlerServer registers the http handlers for service GenerateUnboundMethodsEchoService to "mux".
   139  // UnaryRPC     :call GenerateUnboundMethodsEchoServiceServer directly.
   140  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   141  // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint instead.
   142  func RegisterGenerateUnboundMethodsEchoServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server GenerateUnboundMethodsEchoServiceServer) error {
   143  
   144  	mux.Handle("POST", pattern_GenerateUnboundMethodsEchoService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   145  		ctx, cancel := context.WithCancel(req.Context())
   146  		defer cancel()
   147  		var stream runtime.ServerTransportStream
   148  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   149  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   150  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   151  		if err != nil {
   152  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   153  			return
   154  		}
   155  		resp, md, err := local_request_GenerateUnboundMethodsEchoService_Echo_0(rctx, inboundMarshaler, server, req, pathParams)
   156  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   157  		ctx = runtime.NewServerMetadataContext(ctx, md)
   158  		if err != nil {
   159  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   160  			return
   161  		}
   162  
   163  		forward_GenerateUnboundMethodsEchoService_Echo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   164  
   165  	})
   166  
   167  	mux.Handle("POST", pattern_GenerateUnboundMethodsEchoService_EchoBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   168  		ctx, cancel := context.WithCancel(req.Context())
   169  		defer cancel()
   170  		var stream runtime.ServerTransportStream
   171  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   172  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   173  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   174  		if err != nil {
   175  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   176  			return
   177  		}
   178  		resp, md, err := local_request_GenerateUnboundMethodsEchoService_EchoBody_0(rctx, inboundMarshaler, server, req, pathParams)
   179  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   180  		ctx = runtime.NewServerMetadataContext(ctx, md)
   181  		if err != nil {
   182  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   183  			return
   184  		}
   185  
   186  		forward_GenerateUnboundMethodsEchoService_EchoBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   187  
   188  	})
   189  
   190  	mux.Handle("POST", pattern_GenerateUnboundMethodsEchoService_EchoDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   191  		ctx, cancel := context.WithCancel(req.Context())
   192  		defer cancel()
   193  		var stream runtime.ServerTransportStream
   194  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
   195  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   196  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
   197  		if err != nil {
   198  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   199  			return
   200  		}
   201  		resp, md, err := local_request_GenerateUnboundMethodsEchoService_EchoDelete_0(rctx, inboundMarshaler, server, req, pathParams)
   202  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
   203  		ctx = runtime.NewServerMetadataContext(ctx, md)
   204  		if err != nil {
   205  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   206  			return
   207  		}
   208  
   209  		forward_GenerateUnboundMethodsEchoService_EchoDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   210  
   211  	})
   212  
   213  	return nil
   214  }
   215  
   216  // RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint is same as RegisterGenerateUnboundMethodsEchoServiceHandler but
   217  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   218  func RegisterGenerateUnboundMethodsEchoServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   219  	conn, err := grpc.Dial(endpoint, opts...)
   220  	if err != nil {
   221  		return err
   222  	}
   223  	defer func() {
   224  		if err != nil {
   225  			if cerr := conn.Close(); cerr != nil {
   226  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   227  			}
   228  			return
   229  		}
   230  		go func() {
   231  			<-ctx.Done()
   232  			if cerr := conn.Close(); cerr != nil {
   233  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   234  			}
   235  		}()
   236  	}()
   237  
   238  	return RegisterGenerateUnboundMethodsEchoServiceHandler(ctx, mux, conn)
   239  }
   240  
   241  // RegisterGenerateUnboundMethodsEchoServiceHandler registers the http handlers for service GenerateUnboundMethodsEchoService to "mux".
   242  // The handlers forward requests to the grpc endpoint over "conn".
   243  func RegisterGenerateUnboundMethodsEchoServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
   244  	return RegisterGenerateUnboundMethodsEchoServiceHandlerClient(ctx, mux, NewGenerateUnboundMethodsEchoServiceClient(conn))
   245  }
   246  
   247  // RegisterGenerateUnboundMethodsEchoServiceHandlerClient registers the http handlers for service GenerateUnboundMethodsEchoService
   248  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "GenerateUnboundMethodsEchoServiceClient".
   249  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "GenerateUnboundMethodsEchoServiceClient"
   250  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
   251  // "GenerateUnboundMethodsEchoServiceClient" to call the correct interceptors.
   252  func RegisterGenerateUnboundMethodsEchoServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client GenerateUnboundMethodsEchoServiceClient) error {
   253  
   254  	mux.Handle("POST", pattern_GenerateUnboundMethodsEchoService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   255  		ctx, cancel := context.WithCancel(req.Context())
   256  		defer cancel()
   257  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   258  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   259  		if err != nil {
   260  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   261  			return
   262  		}
   263  		resp, md, err := request_GenerateUnboundMethodsEchoService_Echo_0(rctx, inboundMarshaler, client, req, pathParams)
   264  		ctx = runtime.NewServerMetadataContext(ctx, md)
   265  		if err != nil {
   266  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   267  			return
   268  		}
   269  
   270  		forward_GenerateUnboundMethodsEchoService_Echo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   271  
   272  	})
   273  
   274  	mux.Handle("POST", pattern_GenerateUnboundMethodsEchoService_EchoBody_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   275  		ctx, cancel := context.WithCancel(req.Context())
   276  		defer cancel()
   277  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   278  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   279  		if err != nil {
   280  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   281  			return
   282  		}
   283  		resp, md, err := request_GenerateUnboundMethodsEchoService_EchoBody_0(rctx, inboundMarshaler, client, req, pathParams)
   284  		ctx = runtime.NewServerMetadataContext(ctx, md)
   285  		if err != nil {
   286  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   287  			return
   288  		}
   289  
   290  		forward_GenerateUnboundMethodsEchoService_EchoBody_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   291  
   292  	})
   293  
   294  	mux.Handle("POST", pattern_GenerateUnboundMethodsEchoService_EchoDelete_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   295  		ctx, cancel := context.WithCancel(req.Context())
   296  		defer cancel()
   297  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   298  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   299  		if err != nil {
   300  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   301  			return
   302  		}
   303  		resp, md, err := request_GenerateUnboundMethodsEchoService_EchoDelete_0(rctx, inboundMarshaler, client, req, pathParams)
   304  		ctx = runtime.NewServerMetadataContext(ctx, md)
   305  		if err != nil {
   306  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   307  			return
   308  		}
   309  
   310  		forward_GenerateUnboundMethodsEchoService_EchoDelete_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   311  
   312  	})
   313  
   314  	return nil
   315  }
   316  
   317  var (
   318  	pattern_GenerateUnboundMethodsEchoService_Echo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"grpc.gateway.examples.internal.examplepb.GenerateUnboundMethodsEchoService", "Echo"}, "", runtime.AssumeColonVerbOpt(true)))
   319  
   320  	pattern_GenerateUnboundMethodsEchoService_EchoBody_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"grpc.gateway.examples.internal.examplepb.GenerateUnboundMethodsEchoService", "EchoBody"}, "", runtime.AssumeColonVerbOpt(true)))
   321  
   322  	pattern_GenerateUnboundMethodsEchoService_EchoDelete_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"grpc.gateway.examples.internal.examplepb.GenerateUnboundMethodsEchoService", "EchoDelete"}, "", runtime.AssumeColonVerbOpt(true)))
   323  )
   324  
   325  var (
   326  	forward_GenerateUnboundMethodsEchoService_Echo_0 = runtime.ForwardResponseMessage
   327  
   328  	forward_GenerateUnboundMethodsEchoService_EchoBody_0 = runtime.ForwardResponseMessage
   329  
   330  	forward_GenerateUnboundMethodsEchoService_EchoDelete_0 = runtime.ForwardResponseMessage
   331  )
   332
View as plain text