all: regenerate .pb.go files using cmd/protoc-gen-go-grpc (#3646)
Change regenerate.sh to use cmd/protoc-gen-go-grpc and rerun it. This splits the gRPC service definitions into separate files, but otherwise has no changes.
This commit is contained in:
Damien Neil
@ -4,12 +4,8 @@
|
||||
package echo
|
||||
|
||||
import (
|
||||
context "context"
|
||||
fmt "fmt"
|
||||
proto "github.com/golang/protobuf/proto"
|
||||
grpc "google.golang.org/grpc"
|
||||
codes "google.golang.org/grpc/codes"
|
||||
status "google.golang.org/grpc/status"
|
||||
math "math"
|
||||
)
|
||||
|
||||
@ -131,293 +127,3 @@ var fileDescriptor_2fd1d686b7b805dc = []byte{
|
||||
0xb0, 0xd1, 0x69, 0x62, 0x67, 0xca, 0xaa, 0xf9, 0xeb, 0x4c, 0x9e, 0x4f, 0xfb, 0xff, 0xe2, 0x3b,
|
||||
0x00, 0x00, 0xff, 0xff, 0xf7, 0x79, 0x87, 0xf0, 0x4d, 0x02, 0x00, 0x00,
|
||||
}
|
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
var _ context.Context
|
||||
var _ grpc.ClientConnInterface
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the grpc package it is being compiled against.
|
||||
const _ = grpc.SupportPackageIsVersion6
|
||||
|
||||
// EchoClient is the client API for Echo service.
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
||||
type EchoClient interface {
|
||||
// UnaryEcho is unary echo.
|
||||
UnaryEcho(ctx context.Context, in *EchoRequest, opts ...grpc.CallOption) (*EchoResponse, error)
|
||||
// ServerStreamingEcho is server side streaming.
|
||||
ServerStreamingEcho(ctx context.Context, in *EchoRequest, opts ...grpc.CallOption) (Echo_ServerStreamingEchoClient, error)
|
||||
// ClientStreamingEcho is client side streaming.
|
||||
ClientStreamingEcho(ctx context.Context, opts ...grpc.CallOption) (Echo_ClientStreamingEchoClient, error)
|
||||
// BidirectionalStreamingEcho is bidi streaming.
|
||||
BidirectionalStreamingEcho(ctx context.Context, opts ...grpc.CallOption) (Echo_BidirectionalStreamingEchoClient, error)
|
||||
}
|
||||
|
||||
type echoClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewEchoClient(cc grpc.ClientConnInterface) EchoClient {
|
||||
return &echoClient{cc}
|
||||
}
|
||||
|
||||
func (c *echoClient) UnaryEcho(ctx context.Context, in *EchoRequest, opts ...grpc.CallOption) (*EchoResponse, error) {
|
||||
out := new(EchoResponse)
|
||||
err := c.cc.Invoke(ctx, "/grpc.examples.echo.Echo/UnaryEcho", in, out, opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *echoClient) ServerStreamingEcho(ctx context.Context, in *EchoRequest, opts ...grpc.CallOption) (Echo_ServerStreamingEchoClient, error) {
|
||||
stream, err := c.cc.NewStream(ctx, &_Echo_serviceDesc.Streams[0], "/grpc.examples.echo.Echo/ServerStreamingEcho", opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
x := &echoServerStreamingEchoClient{stream}
|
||||
if err := x.ClientStream.SendMsg(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := x.ClientStream.CloseSend(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return x, nil
|
||||
}
|
||||
|
||||
type Echo_ServerStreamingEchoClient interface {
|
||||
Recv() (*EchoResponse, error)
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
type echoServerStreamingEchoClient struct {
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
func (x *echoServerStreamingEchoClient) Recv() (*EchoResponse, error) {
|
||||
m := new(EchoResponse)
|
||||
if err := x.ClientStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (c *echoClient) ClientStreamingEcho(ctx context.Context, opts ...grpc.CallOption) (Echo_ClientStreamingEchoClient, error) {
|
||||
stream, err := c.cc.NewStream(ctx, &_Echo_serviceDesc.Streams[1], "/grpc.examples.echo.Echo/ClientStreamingEcho", opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
x := &echoClientStreamingEchoClient{stream}
|
||||
return x, nil
|
||||
}
|
||||
|
||||
type Echo_ClientStreamingEchoClient interface {
|
||||
Send(*EchoRequest) error
|
||||
CloseAndRecv() (*EchoResponse, error)
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
type echoClientStreamingEchoClient struct {
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
func (x *echoClientStreamingEchoClient) Send(m *EchoRequest) error {
|
||||
return x.ClientStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func (x *echoClientStreamingEchoClient) CloseAndRecv() (*EchoResponse, error) {
|
||||
if err := x.ClientStream.CloseSend(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
m := new(EchoResponse)
|
||||
if err := x.ClientStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (c *echoClient) BidirectionalStreamingEcho(ctx context.Context, opts ...grpc.CallOption) (Echo_BidirectionalStreamingEchoClient, error) {
|
||||
stream, err := c.cc.NewStream(ctx, &_Echo_serviceDesc.Streams[2], "/grpc.examples.echo.Echo/BidirectionalStreamingEcho", opts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
x := &echoBidirectionalStreamingEchoClient{stream}
|
||||
return x, nil
|
||||
}
|
||||
|
||||
type Echo_BidirectionalStreamingEchoClient interface {
|
||||
Send(*EchoRequest) error
|
||||
Recv() (*EchoResponse, error)
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
type echoBidirectionalStreamingEchoClient struct {
|
||||
grpc.ClientStream
|
||||
}
|
||||
|
||||
func (x *echoBidirectionalStreamingEchoClient) Send(m *EchoRequest) error {
|
||||
return x.ClientStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func (x *echoBidirectionalStreamingEchoClient) Recv() (*EchoResponse, error) {
|
||||
m := new(EchoResponse)
|
||||
if err := x.ClientStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// EchoServer is the server API for Echo service.
|
||||
type EchoServer interface {
|
||||
// UnaryEcho is unary echo.
|
||||
UnaryEcho(context.Context, *EchoRequest) (*EchoResponse, error)
|
||||
// ServerStreamingEcho is server side streaming.
|
||||
ServerStreamingEcho(*EchoRequest, Echo_ServerStreamingEchoServer) error
|
||||
// ClientStreamingEcho is client side streaming.
|
||||
ClientStreamingEcho(Echo_ClientStreamingEchoServer) error
|
||||
// BidirectionalStreamingEcho is bidi streaming.
|
||||
BidirectionalStreamingEcho(Echo_BidirectionalStreamingEchoServer) error
|
||||
}
|
||||
|
||||
// UnimplementedEchoServer can be embedded to have forward compatible implementations.
|
||||
type UnimplementedEchoServer struct {
|
||||
}
|
||||
|
||||
func (*UnimplementedEchoServer) UnaryEcho(ctx context.Context, req *EchoRequest) (*EchoResponse, error) {
|
||||
return nil, status.Errorf(codes.Unimplemented, "method UnaryEcho not implemented")
|
||||
}
|
||||
func (*UnimplementedEchoServer) ServerStreamingEcho(req *EchoRequest, srv Echo_ServerStreamingEchoServer) error {
|
||||
return status.Errorf(codes.Unimplemented, "method ServerStreamingEcho not implemented")
|
||||
}
|
||||
func (*UnimplementedEchoServer) ClientStreamingEcho(srv Echo_ClientStreamingEchoServer) error {
|
||||
return status.Errorf(codes.Unimplemented, "method ClientStreamingEcho not implemented")
|
||||
}
|
||||
func (*UnimplementedEchoServer) BidirectionalStreamingEcho(srv Echo_BidirectionalStreamingEchoServer) error {
|
||||
return status.Errorf(codes.Unimplemented, "method BidirectionalStreamingEcho not implemented")
|
||||
}
|
||||
|
||||
func RegisterEchoServer(s *grpc.Server, srv EchoServer) {
|
||||
s.RegisterService(&_Echo_serviceDesc, srv)
|
||||
}
|
||||
|
||||
func _Echo_UnaryEcho_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(EchoRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EchoServer).UnaryEcho(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: "/grpc.examples.echo.Echo/UnaryEcho",
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EchoServer).UnaryEcho(ctx, req.(*EchoRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _Echo_ServerStreamingEcho_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
m := new(EchoRequest)
|
||||
if err := stream.RecvMsg(m); err != nil {
|
||||
return err
|
||||
}
|
||||
return srv.(EchoServer).ServerStreamingEcho(m, &echoServerStreamingEchoServer{stream})
|
||||
}
|
||||
|
||||
type Echo_ServerStreamingEchoServer interface {
|
||||
Send(*EchoResponse) error
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
type echoServerStreamingEchoServer struct {
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
func (x *echoServerStreamingEchoServer) Send(m *EchoResponse) error {
|
||||
return x.ServerStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func _Echo_ClientStreamingEcho_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
return srv.(EchoServer).ClientStreamingEcho(&echoClientStreamingEchoServer{stream})
|
||||
}
|
||||
|
||||
type Echo_ClientStreamingEchoServer interface {
|
||||
SendAndClose(*EchoResponse) error
|
||||
Recv() (*EchoRequest, error)
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
type echoClientStreamingEchoServer struct {
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
func (x *echoClientStreamingEchoServer) SendAndClose(m *EchoResponse) error {
|
||||
return x.ServerStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func (x *echoClientStreamingEchoServer) Recv() (*EchoRequest, error) {
|
||||
m := new(EchoRequest)
|
||||
if err := x.ServerStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func _Echo_BidirectionalStreamingEcho_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
return srv.(EchoServer).BidirectionalStreamingEcho(&echoBidirectionalStreamingEchoServer{stream})
|
||||
}
|
||||
|
||||
type Echo_BidirectionalStreamingEchoServer interface {
|
||||
Send(*EchoResponse) error
|
||||
Recv() (*EchoRequest, error)
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
type echoBidirectionalStreamingEchoServer struct {
|
||||
grpc.ServerStream
|
||||
}
|
||||
|
||||
func (x *echoBidirectionalStreamingEchoServer) Send(m *EchoResponse) error {
|
||||
return x.ServerStream.SendMsg(m)
|
||||
}
|
||||
|
||||
func (x *echoBidirectionalStreamingEchoServer) Recv() (*EchoRequest, error) {
|
||||
m := new(EchoRequest)
|
||||
if err := x.ServerStream.RecvMsg(m); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
var _Echo_serviceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "grpc.examples.echo.Echo",
|
||||
HandlerType: (*EchoServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "UnaryEcho",
|
||||
Handler: _Echo_UnaryEcho_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{
|
||||
{
|
||||
StreamName: "ServerStreamingEcho",
|
||||
Handler: _Echo_ServerStreamingEcho_Handler,
|
||||
ServerStreams: true,
|
||||
},
|
||||
{
|
||||
StreamName: "ClientStreamingEcho",
|
||||
Handler: _Echo_ClientStreamingEcho_Handler,
|
||||
ClientStreams: true,
|
||||
},
|
||||
{
|
||||
StreamName: "BidirectionalStreamingEcho",
|
||||
Handler: _Echo_BidirectionalStreamingEcho_Handler,
|
||||
ServerStreams: true,
|
||||
ClientStreams: true,
|
||||
},
|
||||
},
|
||||
Metadata: "examples/features/proto/echo/echo.proto",
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user