stream.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/stream.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/golang/protobuf/ptypes/empty"
    19  	"github.com/grpc-ecosystem/grpc-gateway/examples/internal/proto/sub"
    20  	"github.com/grpc-ecosystem/grpc-gateway/runtime"
    21  	"github.com/grpc-ecosystem/grpc-gateway/utilities"
    22  	"google.golang.org/grpc"
    23  	"google.golang.org/grpc/codes"
    24  	"google.golang.org/grpc/grpclog"
    25  	"google.golang.org/grpc/metadata"
    26  	"google.golang.org/grpc/status"
    27  )
    28  
    29  // Suppress "imported and not used" errors
    30  var _ codes.Code
    31  var _ io.Reader
    32  var _ status.Status
    33  var _ = runtime.String
    34  var _ = utilities.NewDoubleArray
    35  var _ = descriptor.ForMessage
    36  var _ = metadata.Join
    37  
    38  func request_StreamService_BulkCreate_0(ctx context.Context, marshaler runtime.Marshaler, client StreamServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
    39  	var metadata runtime.ServerMetadata
    40  	stream, err := client.BulkCreate(ctx)
    41  	if err != nil {
    42  		grpclog.Infof("Failed to start streaming: %v", err)
    43  		return nil, metadata, err
    44  	}
    45  	dec := marshaler.NewDecoder(req.Body)
    46  	for {
    47  		var protoReq ABitOfEverything
    48  		err = dec.Decode(&protoReq)
    49  		if err == io.EOF {
    50  			break
    51  		}
    52  		if err != nil {
    53  			grpclog.Infof("Failed to decode request: %v", err)
    54  			return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
    55  		}
    56  		if err = stream.Send(&protoReq); err != nil {
    57  			if err == io.EOF {
    58  				break
    59  			}
    60  			grpclog.Infof("Failed to send request: %v", err)
    61  			return nil, metadata, err
    62  		}
    63  	}
    64  
    65  	if err := stream.CloseSend(); err != nil {
    66  		grpclog.Infof("Failed to terminate client stream: %v", err)
    67  		return nil, metadata, err
    68  	}
    69  	header, err := stream.Header()
    70  	if err != nil {
    71  		grpclog.Infof("Failed to get header from client: %v", err)
    72  		return nil, metadata, err
    73  	}
    74  	metadata.HeaderMD = header
    75  
    76  	msg, err := stream.CloseAndRecv()
    77  	metadata.TrailerMD = stream.Trailer()
    78  	return msg, metadata, err
    79  
    80  }
    81  
    82  func request_StreamService_List_0(ctx context.Context, marshaler runtime.Marshaler, client StreamServiceClient, req *http.Request, pathParams map[string]string) (StreamService_ListClient, runtime.ServerMetadata, error) {
    83  	var protoReq empty.Empty
    84  	var metadata runtime.ServerMetadata
    85  
    86  	stream, err := client.List(ctx, &protoReq)
    87  	if err != nil {
    88  		return nil, metadata, err
    89  	}
    90  	header, err := stream.Header()
    91  	if err != nil {
    92  		return nil, metadata, err
    93  	}
    94  	metadata.HeaderMD = header
    95  	return stream, metadata, nil
    96  
    97  }
    98  
    99  func request_StreamService_BulkEcho_0(ctx context.Context, marshaler runtime.Marshaler, client StreamServiceClient, req *http.Request, pathParams map[string]string) (StreamService_BulkEchoClient, runtime.ServerMetadata, error) {
   100  	var metadata runtime.ServerMetadata
   101  	stream, err := client.BulkEcho(ctx)
   102  	if err != nil {
   103  		grpclog.Infof("Failed to start streaming: %v", err)
   104  		return nil, metadata, err
   105  	}
   106  	dec := marshaler.NewDecoder(req.Body)
   107  	handleSend := func() error {
   108  		var protoReq sub.StringMessage
   109  		err := dec.Decode(&protoReq)
   110  		if err == io.EOF {
   111  			return err
   112  		}
   113  		if err != nil {
   114  			grpclog.Infof("Failed to decode request: %v", err)
   115  			return err
   116  		}
   117  		if err := stream.Send(&protoReq); err != nil {
   118  			grpclog.Infof("Failed to send request: %v", err)
   119  			return err
   120  		}
   121  		return nil
   122  	}
   123  	if err := handleSend(); err != nil {
   124  		if cerr := stream.CloseSend(); cerr != nil {
   125  			grpclog.Infof("Failed to terminate client stream: %v", cerr)
   126  		}
   127  		if err == io.EOF {
   128  			return stream, metadata, nil
   129  		}
   130  		return nil, metadata, err
   131  	}
   132  	go func() {
   133  		for {
   134  			if err := handleSend(); err != nil {
   135  				break
   136  			}
   137  		}
   138  		if err := stream.CloseSend(); err != nil {
   139  			grpclog.Infof("Failed to terminate client stream: %v", err)
   140  		}
   141  	}()
   142  	header, err := stream.Header()
   143  	if err != nil {
   144  		grpclog.Infof("Failed to get header from client: %v", err)
   145  		return nil, metadata, err
   146  	}
   147  	metadata.HeaderMD = header
   148  	return stream, metadata, nil
   149  }
   150  
   151  // RegisterStreamServiceHandlerServer registers the http handlers for service StreamService to "mux".
   152  // UnaryRPC     :call StreamServiceServer directly.
   153  // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
   154  // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterStreamServiceHandlerFromEndpoint instead.
   155  func RegisterStreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server StreamServiceServer) error {
   156  
   157  	mux.Handle("POST", pattern_StreamService_BulkCreate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   158  		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
   159  		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   160  		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   161  		return
   162  	})
   163  
   164  	mux.Handle("GET", pattern_StreamService_List_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   165  		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
   166  		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   167  		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   168  		return
   169  	})
   170  
   171  	mux.Handle("POST", pattern_StreamService_BulkEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   172  		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
   173  		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   174  		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   175  		return
   176  	})
   177  
   178  	return nil
   179  }
   180  
   181  // RegisterStreamServiceHandlerFromEndpoint is same as RegisterStreamServiceHandler but
   182  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   183  func RegisterStreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   184  	conn, err := grpc.Dial(endpoint, opts...)
   185  	if err != nil {
   186  		return err
   187  	}
   188  	defer func() {
   189  		if err != nil {
   190  			if cerr := conn.Close(); cerr != nil {
   191  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   192  			}
   193  			return
   194  		}
   195  		go func() {
   196  			<-ctx.Done()
   197  			if cerr := conn.Close(); cerr != nil {
   198  				grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
   199  			}
   200  		}()
   201  	}()
   202  
   203  	return RegisterStreamServiceHandler(ctx, mux, conn)
   204  }
   205  
   206  // RegisterStreamServiceHandler registers the http handlers for service StreamService to "mux".
   207  // The handlers forward requests to the grpc endpoint over "conn".
   208  func RegisterStreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
   209  	return RegisterStreamServiceHandlerClient(ctx, mux, NewStreamServiceClient(conn))
   210  }
   211  
   212  // RegisterStreamServiceHandlerClient registers the http handlers for service StreamService
   213  // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "StreamServiceClient".
   214  // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "StreamServiceClient"
   215  // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
   216  // "StreamServiceClient" to call the correct interceptors.
   217  func RegisterStreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client StreamServiceClient) error {
   218  
   219  	mux.Handle("POST", pattern_StreamService_BulkCreate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   220  		ctx, cancel := context.WithCancel(req.Context())
   221  		defer cancel()
   222  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   223  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   224  		if err != nil {
   225  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   226  			return
   227  		}
   228  		resp, md, err := request_StreamService_BulkCreate_0(rctx, inboundMarshaler, client, req, pathParams)
   229  		ctx = runtime.NewServerMetadataContext(ctx, md)
   230  		if err != nil {
   231  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   232  			return
   233  		}
   234  
   235  		forward_StreamService_BulkCreate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
   236  
   237  	})
   238  
   239  	mux.Handle("GET", pattern_StreamService_List_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   240  		ctx, cancel := context.WithCancel(req.Context())
   241  		defer cancel()
   242  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   243  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   244  		if err != nil {
   245  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   246  			return
   247  		}
   248  		resp, md, err := request_StreamService_List_0(rctx, inboundMarshaler, client, req, pathParams)
   249  		ctx = runtime.NewServerMetadataContext(ctx, md)
   250  		if err != nil {
   251  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   252  			return
   253  		}
   254  
   255  		forward_StreamService_List_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
   256  
   257  	})
   258  
   259  	mux.Handle("POST", pattern_StreamService_BulkEcho_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   260  		ctx, cancel := context.WithCancel(req.Context())
   261  		defer cancel()
   262  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   263  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   264  		if err != nil {
   265  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   266  			return
   267  		}
   268  		resp, md, err := request_StreamService_BulkEcho_0(rctx, inboundMarshaler, client, req, pathParams)
   269  		ctx = runtime.NewServerMetadataContext(ctx, md)
   270  		if err != nil {
   271  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   272  			return
   273  		}
   274  
   275  		forward_StreamService_BulkEcho_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
   276  
   277  	})
   278  
   279  	return nil
   280  }
   281  
   282  var (
   283  	pattern_StreamService_BulkCreate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "example", "a_bit_of_everything", "bulk"}, "", runtime.AssumeColonVerbOpt(true)))
   284  
   285  	pattern_StreamService_List_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "example", "a_bit_of_everything"}, "", runtime.AssumeColonVerbOpt(true)))
   286  
   287  	pattern_StreamService_BulkEcho_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "example", "a_bit_of_everything", "echo"}, "", runtime.AssumeColonVerbOpt(true)))
   288  )
   289  
   290  var (
   291  	forward_StreamService_BulkCreate_0 = runtime.ForwardResponseMessage
   292  
   293  	forward_StreamService_List_0 = runtime.ForwardResponseStream
   294  
   295  	forward_StreamService_BulkEcho_0 = runtime.ForwardResponseStream
   296  )
   297
View as plain text