From e3111ef2c16f0ee4bba597a2ab1ab6a2818c2734 Mon Sep 17 00:00:00 2001 From: Andrey Smirnov Date: Tue, 19 Nov 2019 19:31:18 +0300 Subject: [PATCH] Small fixups in preparation to add one-to-many proxying. --- proxy/examples_test.go | 2 +- proxy/handler.go | 43 ++++---- proxy/handler_test.go | 2 +- testservice/test.pb.go | 222 ++++++++++++++++++++++++++++------------- testservice/test.proto | 2 +- 5 files changed, 176 insertions(+), 95 deletions(-) diff --git a/proxy/examples_test.go b/proxy/examples_test.go index 0b4d440..ecbca86 100644 --- a/proxy/examples_test.go +++ b/proxy/examples_test.go @@ -24,7 +24,7 @@ func ExampleRegisterService() { server := grpc.NewServer(grpc.CustomCodec(proxy.Codec())) // Register a TestService with 4 of its methods explicitly. proxy.RegisterService(server, director, - "mwitkow.testproto.TestService", + "smira.testproto.TestService", "PingEmpty", "Ping", "PingError", "PingList") } diff --git a/proxy/handler.go b/proxy/handler.go index d598ea6..0a6fabc 100644 --- a/proxy/handler.go +++ b/proxy/handler.go @@ -62,9 +62,6 @@ type backendConnection struct { connError error clientStream grpc.ClientStream - - clientCtx context.Context - clientCancel context.CancelFunc } // handler is where the real magic of proxying happens. @@ -89,20 +86,21 @@ func (s *handler) handler(srv interface{}, serverStream grpc.ServerStream) error var establishedConnections int backendConnections := make([]backendConnection, len(backends)) + clientCtx, clientCancel := context.WithCancel(serverStream.Context()) + defer clientCancel() + for i := range backends { backendConnections[i].backend = backends[i] - //We require that the backend's returned context inherits from the serverStream.Context(). + // We require that the backend's returned context inherits from the serverStream.Context(). var outgoingCtx context.Context - outgoingCtx, backendConnections[i].backendConn, backendConnections[i].connError = backends[i].GetConnection(serverStream.Context()) + outgoingCtx, backendConnections[i].backendConn, backendConnections[i].connError = backends[i].GetConnection(clientCtx) if backendConnections[i].connError != nil { continue } - backendConnections[i].clientCtx, backendConnections[i].clientCancel = context.WithCancel(outgoingCtx) - - backendConnections[i].clientStream, backendConnections[i].connError = grpc.NewClientStream(backendConnections[i].clientCtx, clientStreamDescForProxying, + backendConnections[i].clientStream, backendConnections[i].connError = grpc.NewClientStream(outgoingCtx, clientStreamDescForProxying, backendConnections[i].backendConn, fullMethodName) if backendConnections[i].connError != nil { @@ -121,14 +119,11 @@ func (s *handler) handler(srv interface{}, serverStream grpc.ServerStream) error return backendConnections[0].connError } - clientStream := backendConnections[0].clientStream - defer backendConnections[0].clientCancel() - // Explicitly *do not close* s2cErrChan and c2sErrChan, otherwise the select below will not terminate. // Channels do not have to be closed, it is just a control flow mechanism, see // https://groups.google.com/forum/#!msg/golang-nuts/pZwdYRGxCIk/qpbHxRRPJdUJ - s2cErrChan := s.forwardServerToClient(serverStream, clientStream) - c2sErrChan := s.forwardClientToServer(clientStream, serverStream) + s2cErrChan := s.forwardServerToClient(serverStream, &backendConnections[0]) + c2sErrChan := s.forwardClientToServer(&backendConnections[0], serverStream) // We don't know which side is going to stop sending first, so we need a select between the two. for i := 0; i < 2; i++ { select { @@ -137,7 +132,7 @@ func (s *handler) handler(srv interface{}, serverStream grpc.ServerStream) error // this is the happy case where the sender has encountered io.EOF, and won't be sending anymore./ // the clientStream>serverStream may continue pumping though. //nolint: errcheck - clientStream.CloseSend() + backendConnections[0].clientStream.CloseSend() break } else { // however, we may have gotten a receive error (stream disconnected, a read error etc) in which case we need @@ -149,7 +144,7 @@ func (s *handler) handler(srv interface{}, serverStream grpc.ServerStream) error // This happens when the clientStream has nothing else to offer (io.EOF), returned a gRPC error. In those two // cases we may have received Trailers as part of the call. In case of other errors (stream closed) the trailers // will be nil. - serverStream.SetTrailer(clientStream.Trailer()) + serverStream.SetTrailer(backendConnections[0].clientStream.Trailer()) // c2sErr will contain RPC error from client code. If not io.EOF return the RPC error as server stream error. if c2sErr != io.EOF { return c2sErr @@ -160,20 +155,28 @@ func (s *handler) handler(srv interface{}, serverStream grpc.ServerStream) error return status.Errorf(codes.Internal, "gRPC proxying should never reach this stage.") } -func (s *handler) forwardClientToServer(src grpc.ClientStream, dst grpc.ServerStream) chan error { +func (s *handler) forwardClientToServer(src *backendConnection, dst grpc.ServerStream) chan error { ret := make(chan error, 1) go func() { f := &frame{} for i := 0; ; i++ { - if err := src.RecvMsg(f); err != nil { + if err := src.clientStream.RecvMsg(f); err != nil { ret <- err // this can be io.EOF which is happy case break } + + var err error + f.payload, err = src.backend.AppendInfo(f.payload) + if err != nil { + ret <- err + break + } + if i == 0 { // This is a bit of a hack, but client to server headers are only readable after first client msg is // received but must be written to server stream before the first msg is flushed. // This is the only place to do it nicely. - md, err := src.Header() + md, err := src.clientStream.Header() if err != nil { ret <- err break @@ -192,7 +195,7 @@ func (s *handler) forwardClientToServer(src grpc.ClientStream, dst grpc.ServerSt return ret } -func (s *handler) forwardServerToClient(src grpc.ServerStream, dst grpc.ClientStream) chan error { +func (s *handler) forwardServerToClient(src grpc.ServerStream, dst *backendConnection) chan error { ret := make(chan error, 1) go func() { f := &frame{} @@ -201,7 +204,7 @@ func (s *handler) forwardServerToClient(src grpc.ServerStream, dst grpc.ClientSt ret <- err // this can be io.EOF which is happy case break } - if err := dst.SendMsg(f); err != nil { + if err := dst.clientStream.SendMsg(f); err != nil { ret <- err break } diff --git a/proxy/handler_test.go b/proxy/handler_test.go index 840de74..d8f844a 100644 --- a/proxy/handler_test.go +++ b/proxy/handler_test.go @@ -234,7 +234,7 @@ func (s *ProxyHappySuite) SetupSuite() { ) // Ping handler is handled as an explicit registration and not as a TransparentHandler. proxy.RegisterService(s.proxy, director, - "mwitkow.testproto.TestService", + "smira.testproto.TestService", "Ping") // Start the serving loops. diff --git a/testservice/test.pb.go b/testservice/test.pb.go index 1f1f482..0b144ff 100644 --- a/testservice/test.pb.go +++ b/testservice/test.pb.go @@ -1,27 +1,16 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: test.proto -// DO NOT EDIT! -/* -Package mwitkow_testproto is a generated protocol buffer package. - -It is generated from these files: - test.proto - -It has these top-level messages: - Empty - PingRequest - PingResponse -*/ -package mwitkow_testproto - -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" +package smira_testproto import ( - context "golang.org/x/net/context" + 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" ) // Reference imports to suppress errors if they are not otherwise used. @@ -33,24 +22,70 @@ var _ = math.Inf // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package type Empty struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Empty) Reset() { *m = Empty{} } +func (m *Empty) String() string { return proto.CompactTextString(m) } +func (*Empty) ProtoMessage() {} +func (*Empty) Descriptor() ([]byte, []int) { + return fileDescriptor_c161fcfdc0c3ff1e, []int{0} +} + +func (m *Empty) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Empty.Unmarshal(m, b) +} +func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Empty.Marshal(b, m, deterministic) +} +func (m *Empty) XXX_Merge(src proto.Message) { + xxx_messageInfo_Empty.Merge(m, src) +} +func (m *Empty) XXX_Size() int { + return xxx_messageInfo_Empty.Size(m) +} +func (m *Empty) XXX_DiscardUnknown() { + xxx_messageInfo_Empty.DiscardUnknown(m) } -func (m *Empty) Reset() { *m = Empty{} } -func (m *Empty) String() string { return proto.CompactTextString(m) } -func (*Empty) ProtoMessage() {} -func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } +var xxx_messageInfo_Empty proto.InternalMessageInfo type PingRequest struct { - Value string `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"` + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PingRequest) Reset() { *m = PingRequest{} } +func (m *PingRequest) String() string { return proto.CompactTextString(m) } +func (*PingRequest) ProtoMessage() {} +func (*PingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_c161fcfdc0c3ff1e, []int{1} +} + +func (m *PingRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PingRequest.Unmarshal(m, b) +} +func (m *PingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PingRequest.Marshal(b, m, deterministic) +} +func (m *PingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PingRequest.Merge(m, src) +} +func (m *PingRequest) XXX_Size() int { + return xxx_messageInfo_PingRequest.Size(m) +} +func (m *PingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PingRequest.DiscardUnknown(m) } -func (m *PingRequest) Reset() { *m = PingRequest{} } -func (m *PingRequest) String() string { return proto.CompactTextString(m) } -func (*PingRequest) ProtoMessage() {} -func (*PingRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } +var xxx_messageInfo_PingRequest proto.InternalMessageInfo func (m *PingRequest) GetValue() string { if m != nil { @@ -60,14 +95,37 @@ func (m *PingRequest) GetValue() string { } type PingResponse struct { - Value string `protobuf:"bytes,1,opt,name=Value" json:"Value,omitempty"` - Counter int32 `protobuf:"varint,2,opt,name=counter" json:"counter,omitempty"` + Value string `protobuf:"bytes,1,opt,name=Value,proto3" json:"Value,omitempty"` + Counter int32 `protobuf:"varint,2,opt,name=counter,proto3" json:"counter,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *PingResponse) Reset() { *m = PingResponse{} } -func (m *PingResponse) String() string { return proto.CompactTextString(m) } -func (*PingResponse) ProtoMessage() {} -func (*PingResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } +func (m *PingResponse) Reset() { *m = PingResponse{} } +func (m *PingResponse) String() string { return proto.CompactTextString(m) } +func (*PingResponse) ProtoMessage() {} +func (*PingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_c161fcfdc0c3ff1e, []int{2} +} + +func (m *PingResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PingResponse.Unmarshal(m, b) +} +func (m *PingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PingResponse.Marshal(b, m, deterministic) +} +func (m *PingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PingResponse.Merge(m, src) +} +func (m *PingResponse) XXX_Size() int { + return xxx_messageInfo_PingResponse.Size(m) +} +func (m *PingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PingResponse proto.InternalMessageInfo func (m *PingResponse) GetValue() string { if m != nil { @@ -84,9 +142,30 @@ func (m *PingResponse) GetCounter() int32 { } func init() { - proto.RegisterType((*Empty)(nil), "mwitkow.testproto.Empty") - proto.RegisterType((*PingRequest)(nil), "mwitkow.testproto.PingRequest") - proto.RegisterType((*PingResponse)(nil), "mwitkow.testproto.PingResponse") + proto.RegisterType((*Empty)(nil), "smira.testproto.Empty") + proto.RegisterType((*PingRequest)(nil), "smira.testproto.PingRequest") + proto.RegisterType((*PingResponse)(nil), "smira.testproto.PingResponse") +} + +func init() { proto.RegisterFile("test.proto", fileDescriptor_c161fcfdc0c3ff1e) } + +var fileDescriptor_c161fcfdc0c3ff1e = []byte{ + // 232 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0x49, 0x2d, 0x2e, + 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x2f, 0xce, 0xcd, 0x2c, 0x4a, 0xd4, 0x03, 0x89, + 0x80, 0x05, 0x94, 0xd8, 0xb9, 0x58, 0x5d, 0x73, 0x0b, 0x4a, 0x2a, 0x95, 0x94, 0xb9, 0xb8, 0x03, + 0x32, 0xf3, 0xd2, 0x83, 0x52, 0x0b, 0x4b, 0x81, 0x92, 0x42, 0x22, 0x5c, 0xac, 0x65, 0x89, 0x39, + 0xa5, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x10, 0x8e, 0x92, 0x1d, 0x17, 0x0f, 0x44, + 0x51, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0x2a, 0x48, 0x55, 0x18, 0xb2, 0x2a, 0x30, 0x47, 0x48, 0x82, + 0x8b, 0x3d, 0x39, 0xbf, 0x34, 0xaf, 0x24, 0xb5, 0x48, 0x82, 0x09, 0x28, 0xce, 0x1a, 0x04, 0xe3, + 0x1a, 0xfd, 0x65, 0xe2, 0xe2, 0x0e, 0x01, 0x1a, 0x1f, 0x9c, 0x5a, 0x54, 0x96, 0x99, 0x9c, 0x2a, + 0xe4, 0xc2, 0xc5, 0x09, 0x32, 0x0f, 0xec, 0x02, 0x21, 0x31, 0x3d, 0x34, 0xc7, 0xe9, 0x81, 0xc5, + 0xa5, 0x64, 0x31, 0xc4, 0x91, 0xdd, 0xa0, 0xc4, 0x20, 0xe4, 0xca, 0xc5, 0x02, 0x12, 0x11, 0x92, + 0xc1, 0xa1, 0x10, 0xec, 0x23, 0xc2, 0xc6, 0x38, 0x43, 0x1d, 0x53, 0x54, 0x94, 0x5f, 0x44, 0xc0, + 0x2c, 0x1c, 0x4e, 0x05, 0x1a, 0xe2, 0xcd, 0xc5, 0x01, 0x52, 0xe8, 0x93, 0x09, 0x0c, 0x43, 0xca, + 0xdc, 0x63, 0xc0, 0x28, 0xe4, 0xcf, 0xc5, 0x05, 0x12, 0x0b, 0x2e, 0x29, 0x4a, 0x4d, 0xcc, 0xa5, + 0xd0, 0x38, 0x0d, 0x46, 0x03, 0xc6, 0x24, 0x36, 0xb0, 0x8c, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, + 0x0a, 0x9f, 0x1b, 0xb7, 0x13, 0x02, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -97,8 +176,9 @@ var _ grpc.ClientConn // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 -// Client API for TestService service - +// TestServiceClient is the client API for TestService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type TestServiceClient interface { PingEmpty(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PingResponse, error) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) @@ -117,7 +197,7 @@ func NewTestServiceClient(cc *grpc.ClientConn) TestServiceClient { func (c *testServiceClient) PingEmpty(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PingResponse, error) { out := new(PingResponse) - err := grpc.Invoke(ctx, "/mwitkow.testproto.TestService/PingEmpty", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/smira.testproto.TestService/PingEmpty", in, out, opts...) if err != nil { return nil, err } @@ -126,7 +206,7 @@ func (c *testServiceClient) PingEmpty(ctx context.Context, in *Empty, opts ...gr func (c *testServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) { out := new(PingResponse) - err := grpc.Invoke(ctx, "/mwitkow.testproto.TestService/Ping", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/smira.testproto.TestService/Ping", in, out, opts...) if err != nil { return nil, err } @@ -135,7 +215,7 @@ func (c *testServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...g func (c *testServiceClient) PingError(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*Empty, error) { out := new(Empty) - err := grpc.Invoke(ctx, "/mwitkow.testproto.TestService/PingError", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/smira.testproto.TestService/PingError", in, out, opts...) if err != nil { return nil, err } @@ -143,7 +223,7 @@ func (c *testServiceClient) PingError(ctx context.Context, in *PingRequest, opts } func (c *testServiceClient) PingList(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (TestService_PingListClient, error) { - stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[0], c.cc, "/mwitkow.testproto.TestService/PingList", opts...) + stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[0], "/smira.testproto.TestService/PingList", opts...) if err != nil { return nil, err } @@ -175,7 +255,7 @@ func (x *testServicePingListClient) Recv() (*PingResponse, error) { } func (c *testServiceClient) PingStream(ctx context.Context, opts ...grpc.CallOption) (TestService_PingStreamClient, error) { - stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[1], c.cc, "/mwitkow.testproto.TestService/PingStream", opts...) + stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[1], "/smira.testproto.TestService/PingStream", opts...) if err != nil { return nil, err } @@ -205,8 +285,7 @@ func (x *testServicePingStreamClient) Recv() (*PingResponse, error) { return m, nil } -// Server API for TestService service - +// TestServiceServer is the server API for TestService service. type TestServiceServer interface { PingEmpty(context.Context, *Empty) (*PingResponse, error) Ping(context.Context, *PingRequest) (*PingResponse, error) @@ -215,6 +294,26 @@ type TestServiceServer interface { PingStream(TestService_PingStreamServer) error } +// UnimplementedTestServiceServer can be embedded to have forward compatible implementations. +type UnimplementedTestServiceServer struct { +} + +func (*UnimplementedTestServiceServer) PingEmpty(ctx context.Context, req *Empty) (*PingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PingEmpty not implemented") +} +func (*UnimplementedTestServiceServer) Ping(ctx context.Context, req *PingRequest) (*PingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented") +} +func (*UnimplementedTestServiceServer) PingError(ctx context.Context, req *PingRequest) (*Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method PingError not implemented") +} +func (*UnimplementedTestServiceServer) PingList(req *PingRequest, srv TestService_PingListServer) error { + return status.Errorf(codes.Unimplemented, "method PingList not implemented") +} +func (*UnimplementedTestServiceServer) PingStream(srv TestService_PingStreamServer) error { + return status.Errorf(codes.Unimplemented, "method PingStream not implemented") +} + func RegisterTestServiceServer(s *grpc.Server, srv TestServiceServer) { s.RegisterService(&_TestService_serviceDesc, srv) } @@ -229,7 +328,7 @@ func _TestService_PingEmpty_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mwitkow.testproto.TestService/PingEmpty", + FullMethod: "/smira.testproto.TestService/PingEmpty", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TestServiceServer).PingEmpty(ctx, req.(*Empty)) @@ -247,7 +346,7 @@ func _TestService_Ping_Handler(srv interface{}, ctx context.Context, dec func(in } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mwitkow.testproto.TestService/Ping", + FullMethod: "/smira.testproto.TestService/Ping", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TestServiceServer).Ping(ctx, req.(*PingRequest)) @@ -265,7 +364,7 @@ func _TestService_PingError_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mwitkow.testproto.TestService/PingError", + FullMethod: "/smira.testproto.TestService/PingError", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TestServiceServer).PingError(ctx, req.(*PingRequest)) @@ -321,7 +420,7 @@ func (x *testServicePingStreamServer) Recv() (*PingRequest, error) { } var _TestService_serviceDesc = grpc.ServiceDesc{ - ServiceName: "mwitkow.testproto.TestService", + ServiceName: "smira.testproto.TestService", HandlerType: (*TestServiceServer)(nil), Methods: []grpc.MethodDesc{ { @@ -352,24 +451,3 @@ var _TestService_serviceDesc = grpc.ServiceDesc{ }, Metadata: "test.proto", } - -func init() { proto.RegisterFile("test.proto", fileDescriptor0) } - -var fileDescriptor0 = []byte{ - // 237 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x8f, 0x31, 0x4b, 0xc4, 0x40, - 0x10, 0x85, 0x6f, 0xd5, 0x78, 0xde, 0x9c, 0x8d, 0x83, 0xc5, 0x62, 0xa1, 0xc7, 0xda, 0xa4, 0x5a, - 0x0e, 0xed, 0xed, 0x44, 0x05, 0x41, 0x49, 0xc4, 0xfe, 0x0c, 0x83, 0x2c, 0x9a, 0x6c, 0xdc, 0x9d, - 0x24, 0xf8, 0x33, 0xfc, 0xc7, 0xb2, 0x1b, 0x85, 0x80, 0x06, 0x2d, 0x52, 0xce, 0x7b, 0x1f, 0x8f, - 0x6f, 0x00, 0x98, 0x3c, 0xeb, 0xda, 0x59, 0xb6, 0x78, 0x50, 0x76, 0x86, 0x5f, 0x6c, 0xa7, 0x43, - 0x16, 0x23, 0x35, 0x87, 0xe4, 0xb2, 0xac, 0xf9, 0x5d, 0x9d, 0xc2, 0xf2, 0xde, 0x54, 0xcf, 0x19, - 0xbd, 0x35, 0xe4, 0x19, 0x0f, 0x21, 0x69, 0x37, 0xaf, 0x0d, 0x49, 0xb1, 0x12, 0xe9, 0x22, 0xeb, - 0x0f, 0x75, 0x01, 0xfb, 0x3d, 0xe4, 0x6b, 0x5b, 0x79, 0x0a, 0xd4, 0xe3, 0x90, 0x8a, 0x07, 0x4a, - 0x98, 0x17, 0xb6, 0xa9, 0x98, 0x9c, 0xdc, 0x5a, 0x89, 0x34, 0xc9, 0xbe, 0xcf, 0xb3, 0x8f, 0x6d, - 0x58, 0x3e, 0x90, 0xe7, 0x9c, 0x5c, 0x6b, 0x0a, 0xc2, 0x6b, 0x58, 0x84, 0xbd, 0x68, 0x80, 0x52, - 0xff, 0xd0, 0xd3, 0xb1, 0x39, 0x3a, 0xf9, 0xa5, 0x19, 0x7a, 0xa8, 0x19, 0xde, 0xc0, 0x4e, 0x48, - 0xf0, 0x78, 0x14, 0x8d, 0x7f, 0xfd, 0x67, 0xea, 0xea, 0x4b, 0xca, 0x39, 0xeb, 0xfe, 0xdc, 0x1b, - 0x95, 0x56, 0x33, 0xbc, 0x83, 0xbd, 0x80, 0xde, 0x1a, 0xcf, 0x13, 0x78, 0xad, 0x05, 0xe6, 0x00, - 0x21, 0xcb, 0xd9, 0xd1, 0xa6, 0x9c, 0x60, 0x32, 0x15, 0x6b, 0xf1, 0xb4, 0x1b, 0x9b, 0xf3, 0xcf, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x4a, 0xc0, 0x8e, 0xe7, 0x29, 0x02, 0x00, 0x00, -} diff --git a/testservice/test.proto b/testservice/test.proto index 54e3cf5..b441246 100644 --- a/testservice/test.proto +++ b/testservice/test.proto @@ -1,6 +1,6 @@ syntax = "proto3"; -package mwitkow.testproto; +package smira.testproto; message Empty { }