cmd/bpa-operator/vendor/github.com/census-instrumentation/opencensus-proto/gen-go/agent/trace/v1/trace_service.pb.gw.go

   1 // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
   2 // source: opencensus/proto/agent/trace/v1/trace_service.proto
   3
   4 /*
   5 Package v1 is a reverse proxy.
   6
   7 It translates gRPC into RESTful JSON APIs.
   8 */
   9 package v1
  10
  11 import (
  12         "io"
  13         "net/http"
  14
  15         "github.com/golang/protobuf/proto"
  16         "github.com/grpc-ecosystem/grpc-gateway/runtime"
  17         "github.com/grpc-ecosystem/grpc-gateway/utilities"
  18         "golang.org/x/net/context"
  19         "google.golang.org/grpc"
  20         "google.golang.org/grpc/codes"
  21         "google.golang.org/grpc/grpclog"
  22         "google.golang.org/grpc/status"
  23 )
  24
  25 var _ codes.Code
  26 var _ io.Reader
  27 var _ status.Status
  28 var _ = runtime.String
  29 var _ = utilities.NewDoubleArray
  30
  31 func request_TraceService_Export_0(ctx context.Context, marshaler runtime.Marshaler, client TraceServiceClient, req *http.Request, pathParams map[string]string) (TraceService_ExportClient, runtime.ServerMetadata, error) {
  32         var metadata runtime.ServerMetadata
  33         stream, err := client.Export(ctx)
  34         if err != nil {
  35                 grpclog.Infof("Failed to start streaming: %v", err)
  36                 return nil, metadata, err
  37         }
  38         newReader, berr := utilities.IOReaderFactory(req.Body)
  39         if berr != nil {
  40                 return nil, metadata, berr
  41         }
  42         dec := marshaler.NewDecoder(newReader())
  43         handleSend := func() error {
  44                 var protoReq ExportTraceServiceRequest
  45                 err := dec.Decode(&protoReq)
  46                 if err == io.EOF {
  47                         return err
  48                 }
  49                 if err != nil {
  50                         grpclog.Infof("Failed to decode request: %v", err)
  51                         return err
  52                 }
  53                 if err := stream.Send(&protoReq); err != nil {
  54                         grpclog.Infof("Failed to send request: %v", err)
  55                         return err
  56                 }
  57                 return nil
  58         }
  59         if err := handleSend(); err != nil {
  60                 if cerr := stream.CloseSend(); cerr != nil {
  61                         grpclog.Infof("Failed to terminate client stream: %v", cerr)
  62                 }
  63                 if err == io.EOF {
  64                         return stream, metadata, nil
  65                 }
  66                 return nil, metadata, err
  67         }
  68         go func() {
  69                 for {
  70                         if err := handleSend(); err != nil {
  71                                 break
  72                         }
  73                 }
  74                 if err := stream.CloseSend(); err != nil {
  75                         grpclog.Infof("Failed to terminate client stream: %v", err)
  76                 }
  77         }()
  78         header, err := stream.Header()
  79         if err != nil {
  80                 grpclog.Infof("Failed to get header from client: %v", err)
  81                 return nil, metadata, err
  82         }
  83         metadata.HeaderMD = header
  84         return stream, metadata, nil
  85 }
  86
  87 // RegisterTraceServiceHandlerFromEndpoint is same as RegisterTraceServiceHandler but
  88 // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
  89 func RegisterTraceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
  90         conn, err := grpc.Dial(endpoint, opts...)
  91         if err != nil {
  92                 return err
  93         }
  94         defer func() {
  95                 if err != nil {
  96                         if cerr := conn.Close(); cerr != nil {
  97                                 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
  98                         }
  99                         return
 100                 }
 101                 go func() {
 102                         <-ctx.Done()
 103                         if cerr := conn.Close(); cerr != nil {
 104                                 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
 105                         }
 106                 }()
 107         }()
 108
 109         return RegisterTraceServiceHandler(ctx, mux, conn)
 110 }
 111
 112 // RegisterTraceServiceHandler registers the http handlers for service TraceService to "mux".
 113 // The handlers forward requests to the grpc endpoint over "conn".
 114 func RegisterTraceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
 115         return RegisterTraceServiceHandlerClient(ctx, mux, NewTraceServiceClient(conn))
 116 }
 117
 118 // RegisterTraceServiceHandlerClient registers the http handlers for service TraceService
 119 // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "TraceServiceClient".
 120 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "TraceServiceClient"
 121 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
 122 // "TraceServiceClient" to call the correct interceptors.
 123 func RegisterTraceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TraceServiceClient) error {
 124
 125         mux.Handle("POST", pattern_TraceService_Export_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 126                 ctx, cancel := context.WithCancel(req.Context())
 127                 defer cancel()
 128                 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
 129                 rctx, err := runtime.AnnotateContext(ctx, mux, req)
 130                 if err != nil {
 131                         runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 132                         return
 133                 }
 134                 resp, md, err := request_TraceService_Export_0(rctx, inboundMarshaler, client, req, pathParams)
 135                 ctx = runtime.NewServerMetadataContext(ctx, md)
 136                 if err != nil {
 137                         runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
 138                         return
 139                 }
 140
 141                 forward_TraceService_Export_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
 142
 143         })
 144
 145         return nil
 146 }
 147
 148 var (
 149         pattern_TraceService_Export_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "trace"}, ""))
 150 )
 151
 152 var (
 153         forward_TraceService_Export_0 = runtime.ForwardResponseStream
 154 )