github.com/s7techlab/cckit@v0.10.5/examples/token/service/burnable/burnable.pb.gw.go (about)

     1  // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
     2  // source: token/service/burnable/burnable.proto
     3  
     4  /*
     5  Package burnable is a reverse proxy.
     6  
     7  It translates gRPC into RESTful JSON APIs.
     8  */
     9  package burnable
    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  var (
    37  	filter_BurnableService_Burn_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
    38  )
    39  
    40  func request_BurnableService_Burn_0(ctx context.Context, marshaler runtime.Marshaler, client BurnableServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    41  	var protoReq BurnRequest
    42  	var metadata runtime.ServerMetadata
    43  
    44  	if err := req.ParseForm(); err != nil {
    45  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    46  	}
    47  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_BurnableService_Burn_0); err != nil {
    48  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    49  	}
    50  
    51  	msg, err := client.Burn(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
    52  	return msg, metadata, err
    53  
    54  }
    55  
    56  func local_request_BurnableService_Burn_0(ctx context.Context, marshaler runtime.Marshaler, server BurnableServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    57  	var protoReq BurnRequest
    58  	var metadata runtime.ServerMetadata
    59  
    60  	if err := req.ParseForm(); err != nil {
    61  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    62  	}
    63  	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_BurnableService_Burn_0); err != nil {
    64  		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    65  	}
    66  
    67  	msg, err := server.Burn(ctx, &protoReq)
    68  	return msg, metadata, err
    69  
    70  }
    71  
    72  // RegisterBurnableServiceHandlerServer registers the http handlers for service BurnableService to "mux".
    73  // UnaryRPC     :call BurnableServiceServer directly.
    74  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
    75  // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterBurnableServiceHandlerFromEndpoint instead.
    76  func RegisterBurnableServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server BurnableServiceServer) error {
    77  
    78  	mux.Handle("POST", pattern_BurnableService_Burn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
    79  		ctx, cancel := context.WithCancel(req.Context())
    80  		defer cancel()
    81  		var stream runtime.ServerTransportStream
    82  		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
    83  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
    84  		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
    85  		if err != nil {
    86  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
    87  			return
    88  		}
    89  		resp, md, err := local_request_BurnableService_Burn_0(rctx, inboundMarshaler, server, req, pathParams)
    90  		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
    91  		ctx = runtime.NewServerMetadataContext(ctx, md)
    92  		if err != nil {
    93  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
    94  			return
    95  		}
    96  
    97  		forward_BurnableService_Burn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
    98  
    99  	})
   100  
   101  	return nil
   102  }
   103  
   104  // RegisterBurnableServiceHandlerFromEndpoint is same as RegisterBurnableServiceHandler but
   105  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   106  func RegisterBurnableServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   107  	conn, err := grpc.Dial(endpoint, opts...)
   108  	if err != nil {
   109  		return err
   110  	}
   111  	defer func() {
   112  		if err != nil {
   113  			if cerr := conn.Close(); cerr != nil {
   114  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   115  			}
   116  			return
   117  		}
   118  		go func() {
   119  			<-ctx.Done()
   120  			if cerr := conn.Close(); cerr != nil {
   121  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   122  			}
   123  		}()
   124  	}()
   125  
   126  	return RegisterBurnableServiceHandler(ctx, mux, conn)
   127  }
   128  
   129  // RegisterBurnableServiceHandler registers the http handlers for service BurnableService to "mux".
   130  // The handlers forward requests to the grpc endpoint over "conn".
   131  func RegisterBurnableServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
   132  	return RegisterBurnableServiceHandlerClient(ctx, mux, NewBurnableServiceClient(conn))
   133  }
   134  
   135  // RegisterBurnableServiceHandlerClient registers the http handlers for service BurnableService
   136  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "BurnableServiceClient".
   137  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "BurnableServiceClient"
   138  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
   139  // "BurnableServiceClient" to call the correct interceptors.
   140  func RegisterBurnableServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client BurnableServiceClient) error {
   141  
   142  	mux.Handle("POST", pattern_BurnableService_Burn_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   143  		ctx, cancel := context.WithCancel(req.Context())
   144  		defer cancel()
   145  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   146  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   147  		if err != nil {
   148  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   149  			return
   150  		}
   151  		resp, md, err := request_BurnableService_Burn_0(rctx, inboundMarshaler, client, req, pathParams)
   152  		ctx = runtime.NewServerMetadataContext(ctx, md)
   153  		if err != nil {
   154  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   155  			return
   156  		}
   157  
   158  		forward_BurnableService_Burn_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   159  
   160  	})
   161  
   162  	return nil
   163  }
   164  
   165  var (
   166  	pattern_BurnableService_Burn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"burn"}, "", runtime.AssumeColonVerbOpt(true)))
   167  )
   168  
   169  var (
   170  	forward_BurnableService_Burn_0 = runtime.ForwardResponseMessage
   171  )