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 )