echoserver.pb.gw.go

Documentation: github.com/tmc/grpc-websocket-proxy/_examples/cmd/wsechoserver/echoserver

     1  // Code generated by protoc-gen-grpc-gateway
     2  // source: echoserver.proto
     3  // DO NOT EDIT!
     4  
     5  /*
     6  Package echoserver is a reverse proxy.
     7  
     8  It translates gRPC into RESTful JSON APIs.
     9  */
    10  package echoserver
    11  
    12  import (
    13  	"io"
    14  	"net/http"
    15  
    16  	"github.com/golang/protobuf/proto"
    17  	"github.com/grpc-ecosystem/grpc-gateway/runtime"
    18  	"github.com/grpc-ecosystem/grpc-gateway/utilities"
    19  	"golang.org/x/net/context"
    20  	"google.golang.org/grpc"
    21  	"google.golang.org/grpc/codes"
    22  	"google.golang.org/grpc/grpclog"
    23  	"google.golang.org/grpc/status"
    24  )
    25  
    26  var _ codes.Code
    27  var _ io.Reader
    28  var _ status.Status
    29  var _ = runtime.String
    30  var _ = utilities.NewDoubleArray
    31  
    32  func request_EchoService_Echo_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (EchoService_EchoClient, runtime.ServerMetadata, error) {
    33  	var metadata runtime.ServerMetadata
    34  	stream, err := client.Echo(ctx)
    35  	if err != nil {
    36  		grpclog.Printf("Failed to start streaming: %v", err)
    37  		return nil, metadata, err
    38  	}
    39  	dec := marshaler.NewDecoder(req.Body)
    40  	handleSend := func() error {
    41  		var protoReq EchoRequest
    42  		err = dec.Decode(&protoReq)
    43  		if err == io.EOF {
    44  			return err
    45  		}
    46  		if err != nil {
    47  			grpclog.Printf("Failed to decode request: %v", err)
    48  			return err
    49  		}
    50  		if err = stream.Send(&protoReq); err != nil {
    51  			grpclog.Printf("Failed to send request: %v", err)
    52  			return err
    53  		}
    54  		return nil
    55  	}
    56  	if err := handleSend(); err != nil {
    57  		if cerr := stream.CloseSend(); cerr != nil {
    58  			grpclog.Printf("Failed to terminate client stream: %v", cerr)
    59  		}
    60  		if err == io.EOF {
    61  			return stream, metadata, nil
    62  		}
    63  		return nil, metadata, err
    64  	}
    65  	go func() {
    66  		for {
    67  			if err := handleSend(); err != nil {
    68  				break
    69  			}
    70  		}
    71  		if err := stream.CloseSend(); err != nil {
    72  			grpclog.Printf("Failed to terminate client stream: %v", err)
    73  		}
    74  	}()
    75  	header, err := stream.Header()
    76  	if err != nil {
    77  		grpclog.Printf("Failed to get header from client: %v", err)
    78  		return nil, metadata, err
    79  	}
    80  	metadata.HeaderMD = header
    81  	return stream, metadata, nil
    82  }
    83  
    84  func request_EchoService_Stream_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (EchoService_StreamClient, runtime.ServerMetadata, error) {
    85  	var protoReq Empty
    86  	var metadata runtime.ServerMetadata
    87  
    88  	stream, err := client.Stream(ctx, &protoReq)
    89  	if err != nil {
    90  		return nil, metadata, err
    91  	}
    92  	header, err := stream.Header()
    93  	if err != nil {
    94  		return nil, metadata, err
    95  	}
    96  	metadata.HeaderMD = header
    97  	return stream, metadata, nil
    98  
    99  }
   100  
   101  func request_EchoService_Heartbeats_0(ctx context.Context, marshaler runtime.Marshaler, client EchoServiceClient, req *http.Request, pathParams map[string]string) (EchoService_HeartbeatsClient, runtime.ServerMetadata, error) {
   102  	var metadata runtime.ServerMetadata
   103  	stream, err := client.Heartbeats(ctx)
   104  	if err != nil {
   105  		grpclog.Printf("Failed to start streaming: %v", err)
   106  		return nil, metadata, err
   107  	}
   108  	dec := marshaler.NewDecoder(req.Body)
   109  	handleSend := func() error {
   110  		var protoReq Empty
   111  		err = dec.Decode(&protoReq)
   112  		if err == io.EOF {
   113  			return err
   114  		}
   115  		if err != nil {
   116  			grpclog.Printf("Failed to decode request: %v", err)
   117  			return err
   118  		}
   119  		if err = stream.Send(&protoReq); err != nil {
   120  			grpclog.Printf("Failed to send request: %v", err)
   121  			return err
   122  		}
   123  		return nil
   124  	}
   125  	if err := handleSend(); err != nil {
   126  		if cerr := stream.CloseSend(); cerr != nil {
   127  			grpclog.Printf("Failed to terminate client stream: %v", cerr)
   128  		}
   129  		if err == io.EOF {
   130  			return stream, metadata, nil
   131  		}
   132  		return nil, metadata, err
   133  	}
   134  	go func() {
   135  		for {
   136  			if err := handleSend(); err != nil {
   137  				break
   138  			}
   139  		}
   140  		if err := stream.CloseSend(); err != nil {
   141  			grpclog.Printf("Failed to terminate client stream: %v", err)
   142  		}
   143  	}()
   144  	header, err := stream.Header()
   145  	if err != nil {
   146  		grpclog.Printf("Failed to get header from client: %v", err)
   147  		return nil, metadata, err
   148  	}
   149  	metadata.HeaderMD = header
   150  	return stream, metadata, nil
   151  }
   152  
   153  // RegisterEchoServiceHandlerFromEndpoint is same as RegisterEchoServiceHandler but
   154  // automatically dials to "endpoint" and closes the connection when "ctx" gets done.
   155  func RegisterEchoServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
   156  	conn, err := grpc.Dial(endpoint, opts...)
   157  	if err != nil {
   158  		return err
   159  	}
   160  	defer func() {
   161  		if err != nil {
   162  			if cerr := conn.Close(); cerr != nil {
   163  				grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
   164  			}
   165  			return
   166  		}
   167  		go func() {
   168  			<-ctx.Done()
   169  			if cerr := conn.Close(); cerr != nil {
   170  				grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr)
   171  			}
   172  		}()
   173  	}()
   174  
   175  	return RegisterEchoServiceHandler(ctx, mux, conn)
   176  }
   177  
   178  // RegisterEchoServiceHandler registers the http handlers for service EchoService to "mux".
   179  // The handlers forward requests to the grpc endpoint over "conn".
   180  func RegisterEchoServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
   181  	client := NewEchoServiceClient(conn)
   182  
   183  	mux.Handle("POST", pattern_EchoService_Echo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   184  		ctx, cancel := context.WithCancel(ctx)
   185  		defer cancel()
   186  		if cn, ok := w.(http.CloseNotifier); ok {
   187  			go func(done <-chan struct{}, closed <-chan bool) {
   188  				select {
   189  				case <-done:
   190  				case <-closed:
   191  					cancel()
   192  				}
   193  			}(ctx.Done(), cn.CloseNotify())
   194  		}
   195  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   196  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   197  		if err != nil {
   198  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   199  		}
   200  		resp, md, err := request_EchoService_Echo_0(rctx, inboundMarshaler, client, req, pathParams)
   201  		ctx = runtime.NewServerMetadataContext(ctx, md)
   202  		if err != nil {
   203  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   204  			return
   205  		}
   206  
   207  		forward_EchoService_Echo_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
   208  
   209  	})
   210  
   211  	mux.Handle("GET", pattern_EchoService_Stream_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   212  		ctx, cancel := context.WithCancel(ctx)
   213  		defer cancel()
   214  		if cn, ok := w.(http.CloseNotifier); ok {
   215  			go func(done <-chan struct{}, closed <-chan bool) {
   216  				select {
   217  				case <-done:
   218  				case <-closed:
   219  					cancel()
   220  				}
   221  			}(ctx.Done(), cn.CloseNotify())
   222  		}
   223  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   224  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   225  		if err != nil {
   226  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   227  		}
   228  		resp, md, err := request_EchoService_Stream_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_EchoService_Stream_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
   236  
   237  	})
   238  
   239  	mux.Handle("POST", pattern_EchoService_Heartbeats_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
   240  		ctx, cancel := context.WithCancel(ctx)
   241  		defer cancel()
   242  		if cn, ok := w.(http.CloseNotifier); ok {
   243  			go func(done <-chan struct{}, closed <-chan bool) {
   244  				select {
   245  				case <-done:
   246  				case <-closed:
   247  					cancel()
   248  				}
   249  			}(ctx.Done(), cn.CloseNotify())
   250  		}
   251  		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
   252  		rctx, err := runtime.AnnotateContext(ctx, mux, req)
   253  		if err != nil {
   254  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   255  		}
   256  		resp, md, err := request_EchoService_Heartbeats_0(rctx, inboundMarshaler, client, req, pathParams)
   257  		ctx = runtime.NewServerMetadataContext(ctx, md)
   258  		if err != nil {
   259  			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
   260  			return
   261  		}
   262  
   263  		forward_EchoService_Heartbeats_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
   264  
   265  	})
   266  
   267  	return nil
   268  }
   269  
   270  var (
   271  	pattern_EchoService_Echo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"echo"}, ""))
   272  
   273  	pattern_EchoService_Stream_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"echo"}, ""))
   274  
   275  	pattern_EchoService_Heartbeats_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"heartbeats"}, ""))
   276  )
   277  
   278  var (
   279  	forward_EchoService_Echo_0 = runtime.ForwardResponseStream
   280  
   281  	forward_EchoService_Stream_0 = runtime.ForwardResponseStream
   282  
   283  	forward_EchoService_Heartbeats_0 = runtime.ForwardResponseStream
   284  )
   285
View as plain text