1// Code generated by protoc-gen-go. DO NOT EDIT. 2// source: grpc_testing/test.proto 3 4package grpc_testing 5 6import ( 7 context "context" 8 fmt "fmt" 9 proto "github.com/golang/protobuf/proto" 10 grpc "google.golang.org/grpc" 11 codes "google.golang.org/grpc/codes" 12 status "google.golang.org/grpc/status" 13 math "math" 14) 15 16// Reference imports to suppress errors if they are not otherwise used. 17var _ = proto.Marshal 18var _ = fmt.Errorf 19var _ = math.Inf 20 21// This is a compile-time assertion to ensure that this generated file 22// is compatible with the proto package it is being compiled against. 23// A compilation error at this line likely means your copy of the 24// proto package needs to be updated. 25const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package 26 27type SimpleRequest struct { 28 Id int32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` 29 XXX_NoUnkeyedLiteral struct{} `json:"-"` 30 XXX_unrecognized []byte `json:"-"` 31 XXX_sizecache int32 `json:"-"` 32} 33 34func (m *SimpleRequest) Reset() { *m = SimpleRequest{} } 35func (m *SimpleRequest) String() string { return proto.CompactTextString(m) } 36func (*SimpleRequest) ProtoMessage() {} 37func (*SimpleRequest) Descriptor() ([]byte, []int) { 38 return fileDescriptor_e1cda82041fed8bf, []int{0} 39} 40 41func (m *SimpleRequest) XXX_Unmarshal(b []byte) error { 42 return xxx_messageInfo_SimpleRequest.Unmarshal(m, b) 43} 44func (m *SimpleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 45 return xxx_messageInfo_SimpleRequest.Marshal(b, m, deterministic) 46} 47func (m *SimpleRequest) XXX_Merge(src proto.Message) { 48 xxx_messageInfo_SimpleRequest.Merge(m, src) 49} 50func (m *SimpleRequest) XXX_Size() int { 51 return xxx_messageInfo_SimpleRequest.Size(m) 52} 53func (m *SimpleRequest) XXX_DiscardUnknown() { 54 xxx_messageInfo_SimpleRequest.DiscardUnknown(m) 55} 56 57var xxx_messageInfo_SimpleRequest proto.InternalMessageInfo 58 59func (m *SimpleRequest) GetId() int32 { 60 if m != nil { 61 return m.Id 62 } 63 return 0 64} 65 66type SimpleResponse struct { 67 Id int32 `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"` 68 XXX_NoUnkeyedLiteral struct{} `json:"-"` 69 XXX_unrecognized []byte `json:"-"` 70 XXX_sizecache int32 `json:"-"` 71} 72 73func (m *SimpleResponse) Reset() { *m = SimpleResponse{} } 74func (m *SimpleResponse) String() string { return proto.CompactTextString(m) } 75func (*SimpleResponse) ProtoMessage() {} 76func (*SimpleResponse) Descriptor() ([]byte, []int) { 77 return fileDescriptor_e1cda82041fed8bf, []int{1} 78} 79 80func (m *SimpleResponse) XXX_Unmarshal(b []byte) error { 81 return xxx_messageInfo_SimpleResponse.Unmarshal(m, b) 82} 83func (m *SimpleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 84 return xxx_messageInfo_SimpleResponse.Marshal(b, m, deterministic) 85} 86func (m *SimpleResponse) XXX_Merge(src proto.Message) { 87 xxx_messageInfo_SimpleResponse.Merge(m, src) 88} 89func (m *SimpleResponse) XXX_Size() int { 90 return xxx_messageInfo_SimpleResponse.Size(m) 91} 92func (m *SimpleResponse) XXX_DiscardUnknown() { 93 xxx_messageInfo_SimpleResponse.DiscardUnknown(m) 94} 95 96var xxx_messageInfo_SimpleResponse proto.InternalMessageInfo 97 98func (m *SimpleResponse) GetId() int32 { 99 if m != nil { 100 return m.Id 101 } 102 return 0 103} 104 105func init() { 106 proto.RegisterType((*SimpleRequest)(nil), "grpc.testing.SimpleRequest") 107 proto.RegisterType((*SimpleResponse)(nil), "grpc.testing.SimpleResponse") 108} 109 110func init() { proto.RegisterFile("grpc_testing/test.proto", fileDescriptor_e1cda82041fed8bf) } 111 112var fileDescriptor_e1cda82041fed8bf = []byte{ 113 // 202 bytes of a gzipped FileDescriptorProto 114 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4f, 0x2f, 0x2a, 0x48, 115 0x8e, 0x2f, 0x49, 0x2d, 0x2e, 0xc9, 0xcc, 0x4b, 0xd7, 0x07, 0xd1, 0x7a, 0x05, 0x45, 0xf9, 0x25, 116 0xf9, 0x42, 0x3c, 0x20, 0x09, 0x3d, 0xa8, 0x84, 0x92, 0x3c, 0x17, 0x6f, 0x70, 0x66, 0x6e, 0x41, 117 0x4e, 0x6a, 0x50, 0x6a, 0x61, 0x69, 0x6a, 0x71, 0x89, 0x10, 0x1f, 0x17, 0x53, 0x66, 0x8a, 0x04, 118 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x53, 0x66, 0x8a, 0x92, 0x02, 0x17, 0x1f, 0x4c, 0x41, 0x71, 119 0x41, 0x7e, 0x5e, 0x71, 0x2a, 0x54, 0x05, 0x33, 0x4c, 0x85, 0xd1, 0x09, 0x26, 0x2e, 0xee, 0x90, 120 0xd4, 0xe2, 0x92, 0xe0, 0xd4, 0xa2, 0xb2, 0xcc, 0xe4, 0x54, 0x21, 0x37, 0x2e, 0xce, 0xd0, 0xbc, 121 0xc4, 0xa2, 0x4a, 0xe7, 0xc4, 0x9c, 0x1c, 0x21, 0x69, 0x3d, 0x64, 0xeb, 0xf4, 0x50, 0xec, 0x92, 122 0x92, 0xc1, 0x2e, 0x09, 0xb5, 0xc7, 0x9f, 0x8b, 0xcf, 0xad, 0x34, 0x27, 0xc7, 0xa5, 0xb4, 0x20, 123 0x27, 0xb5, 0x82, 0x42, 0xc3, 0x34, 0x18, 0x0d, 0x18, 0x85, 0xfc, 0xb9, 0x04, 0x9c, 0x73, 0x32, 124 0x53, 0xf3, 0x4a, 0x82, 0x4b, 0x8a, 0x52, 0x13, 0x73, 0x29, 0x36, 0x12, 0x64, 0x20, 0xc8, 0xd3, 125 0xa9, 0x45, 0x54, 0x31, 0xd0, 0x80, 0x31, 0x89, 0x0d, 0x1c, 0x45, 0xc6, 0x80, 0x00, 0x00, 0x00, 126 0xff, 0xff, 0x4c, 0x43, 0x27, 0x67, 0xbd, 0x01, 0x00, 0x00, 127} 128 129// Reference imports to suppress errors if they are not otherwise used. 130var _ context.Context 131var _ grpc.ClientConnInterface 132 133// This is a compile-time assertion to ensure that this generated file 134// is compatible with the grpc package it is being compiled against. 135const _ = grpc.SupportPackageIsVersion6 136 137// TestServiceClient is the client API for TestService service. 138// 139// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 140type TestServiceClient interface { 141 // One request followed by one response. 142 // The server returns the client id as-is. 143 UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) 144 // A sequence of requests with each request served by the server immediately. 145 // As one request could lead to multiple responses, this interface 146 // demonstrates the idea of full duplexing. 147 FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) 148 // Client stream 149 ClientStreamCall(ctx context.Context, opts ...grpc.CallOption) (TestService_ClientStreamCallClient, error) 150 // Server stream 151 ServerStreamCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (TestService_ServerStreamCallClient, error) 152} 153 154type testServiceClient struct { 155 cc grpc.ClientConnInterface 156} 157 158func NewTestServiceClient(cc grpc.ClientConnInterface) TestServiceClient { 159 return &testServiceClient{cc} 160} 161 162func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) { 163 out := new(SimpleResponse) 164 err := c.cc.Invoke(ctx, "/grpc.testing.TestService/UnaryCall", in, out, opts...) 165 if err != nil { 166 return nil, err 167 } 168 return out, nil 169} 170 171func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) { 172 stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[0], "/grpc.testing.TestService/FullDuplexCall", opts...) 173 if err != nil { 174 return nil, err 175 } 176 x := &testServiceFullDuplexCallClient{stream} 177 return x, nil 178} 179 180type TestService_FullDuplexCallClient interface { 181 Send(*SimpleRequest) error 182 Recv() (*SimpleResponse, error) 183 grpc.ClientStream 184} 185 186type testServiceFullDuplexCallClient struct { 187 grpc.ClientStream 188} 189 190func (x *testServiceFullDuplexCallClient) Send(m *SimpleRequest) error { 191 return x.ClientStream.SendMsg(m) 192} 193 194func (x *testServiceFullDuplexCallClient) Recv() (*SimpleResponse, error) { 195 m := new(SimpleResponse) 196 if err := x.ClientStream.RecvMsg(m); err != nil { 197 return nil, err 198 } 199 return m, nil 200} 201 202func (c *testServiceClient) ClientStreamCall(ctx context.Context, opts ...grpc.CallOption) (TestService_ClientStreamCallClient, error) { 203 stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[1], "/grpc.testing.TestService/ClientStreamCall", opts...) 204 if err != nil { 205 return nil, err 206 } 207 x := &testServiceClientStreamCallClient{stream} 208 return x, nil 209} 210 211type TestService_ClientStreamCallClient interface { 212 Send(*SimpleRequest) error 213 CloseAndRecv() (*SimpleResponse, error) 214 grpc.ClientStream 215} 216 217type testServiceClientStreamCallClient struct { 218 grpc.ClientStream 219} 220 221func (x *testServiceClientStreamCallClient) Send(m *SimpleRequest) error { 222 return x.ClientStream.SendMsg(m) 223} 224 225func (x *testServiceClientStreamCallClient) CloseAndRecv() (*SimpleResponse, error) { 226 if err := x.ClientStream.CloseSend(); err != nil { 227 return nil, err 228 } 229 m := new(SimpleResponse) 230 if err := x.ClientStream.RecvMsg(m); err != nil { 231 return nil, err 232 } 233 return m, nil 234} 235 236func (c *testServiceClient) ServerStreamCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (TestService_ServerStreamCallClient, error) { 237 stream, err := c.cc.NewStream(ctx, &_TestService_serviceDesc.Streams[2], "/grpc.testing.TestService/ServerStreamCall", opts...) 238 if err != nil { 239 return nil, err 240 } 241 x := &testServiceServerStreamCallClient{stream} 242 if err := x.ClientStream.SendMsg(in); err != nil { 243 return nil, err 244 } 245 if err := x.ClientStream.CloseSend(); err != nil { 246 return nil, err 247 } 248 return x, nil 249} 250 251type TestService_ServerStreamCallClient interface { 252 Recv() (*SimpleResponse, error) 253 grpc.ClientStream 254} 255 256type testServiceServerStreamCallClient struct { 257 grpc.ClientStream 258} 259 260func (x *testServiceServerStreamCallClient) Recv() (*SimpleResponse, error) { 261 m := new(SimpleResponse) 262 if err := x.ClientStream.RecvMsg(m); err != nil { 263 return nil, err 264 } 265 return m, nil 266} 267 268// TestServiceServer is the server API for TestService service. 269type TestServiceServer interface { 270 // One request followed by one response. 271 // The server returns the client id as-is. 272 UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) 273 // A sequence of requests with each request served by the server immediately. 274 // As one request could lead to multiple responses, this interface 275 // demonstrates the idea of full duplexing. 276 FullDuplexCall(TestService_FullDuplexCallServer) error 277 // Client stream 278 ClientStreamCall(TestService_ClientStreamCallServer) error 279 // Server stream 280 ServerStreamCall(*SimpleRequest, TestService_ServerStreamCallServer) error 281} 282 283// UnimplementedTestServiceServer can be embedded to have forward compatible implementations. 284type UnimplementedTestServiceServer struct { 285} 286 287func (*UnimplementedTestServiceServer) UnaryCall(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) { 288 return nil, status.Errorf(codes.Unimplemented, "method UnaryCall not implemented") 289} 290func (*UnimplementedTestServiceServer) FullDuplexCall(srv TestService_FullDuplexCallServer) error { 291 return status.Errorf(codes.Unimplemented, "method FullDuplexCall not implemented") 292} 293func (*UnimplementedTestServiceServer) ClientStreamCall(srv TestService_ClientStreamCallServer) error { 294 return status.Errorf(codes.Unimplemented, "method ClientStreamCall not implemented") 295} 296func (*UnimplementedTestServiceServer) ServerStreamCall(req *SimpleRequest, srv TestService_ServerStreamCallServer) error { 297 return status.Errorf(codes.Unimplemented, "method ServerStreamCall not implemented") 298} 299 300func RegisterTestServiceServer(s *grpc.Server, srv TestServiceServer) { 301 s.RegisterService(&_TestService_serviceDesc, srv) 302} 303 304func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 305 in := new(SimpleRequest) 306 if err := dec(in); err != nil { 307 return nil, err 308 } 309 if interceptor == nil { 310 return srv.(TestServiceServer).UnaryCall(ctx, in) 311 } 312 info := &grpc.UnaryServerInfo{ 313 Server: srv, 314 FullMethod: "/grpc.testing.TestService/UnaryCall", 315 } 316 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 317 return srv.(TestServiceServer).UnaryCall(ctx, req.(*SimpleRequest)) 318 } 319 return interceptor(ctx, in, info, handler) 320} 321 322func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error { 323 return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream}) 324} 325 326type TestService_FullDuplexCallServer interface { 327 Send(*SimpleResponse) error 328 Recv() (*SimpleRequest, error) 329 grpc.ServerStream 330} 331 332type testServiceFullDuplexCallServer struct { 333 grpc.ServerStream 334} 335 336func (x *testServiceFullDuplexCallServer) Send(m *SimpleResponse) error { 337 return x.ServerStream.SendMsg(m) 338} 339 340func (x *testServiceFullDuplexCallServer) Recv() (*SimpleRequest, error) { 341 m := new(SimpleRequest) 342 if err := x.ServerStream.RecvMsg(m); err != nil { 343 return nil, err 344 } 345 return m, nil 346} 347 348func _TestService_ClientStreamCall_Handler(srv interface{}, stream grpc.ServerStream) error { 349 return srv.(TestServiceServer).ClientStreamCall(&testServiceClientStreamCallServer{stream}) 350} 351 352type TestService_ClientStreamCallServer interface { 353 SendAndClose(*SimpleResponse) error 354 Recv() (*SimpleRequest, error) 355 grpc.ServerStream 356} 357 358type testServiceClientStreamCallServer struct { 359 grpc.ServerStream 360} 361 362func (x *testServiceClientStreamCallServer) SendAndClose(m *SimpleResponse) error { 363 return x.ServerStream.SendMsg(m) 364} 365 366func (x *testServiceClientStreamCallServer) Recv() (*SimpleRequest, error) { 367 m := new(SimpleRequest) 368 if err := x.ServerStream.RecvMsg(m); err != nil { 369 return nil, err 370 } 371 return m, nil 372} 373 374func _TestService_ServerStreamCall_Handler(srv interface{}, stream grpc.ServerStream) error { 375 m := new(SimpleRequest) 376 if err := stream.RecvMsg(m); err != nil { 377 return err 378 } 379 return srv.(TestServiceServer).ServerStreamCall(m, &testServiceServerStreamCallServer{stream}) 380} 381 382type TestService_ServerStreamCallServer interface { 383 Send(*SimpleResponse) error 384 grpc.ServerStream 385} 386 387type testServiceServerStreamCallServer struct { 388 grpc.ServerStream 389} 390 391func (x *testServiceServerStreamCallServer) Send(m *SimpleResponse) error { 392 return x.ServerStream.SendMsg(m) 393} 394 395var _TestService_serviceDesc = grpc.ServiceDesc{ 396 ServiceName: "grpc.testing.TestService", 397 HandlerType: (*TestServiceServer)(nil), 398 Methods: []grpc.MethodDesc{ 399 { 400 MethodName: "UnaryCall", 401 Handler: _TestService_UnaryCall_Handler, 402 }, 403 }, 404 Streams: []grpc.StreamDesc{ 405 { 406 StreamName: "FullDuplexCall", 407 Handler: _TestService_FullDuplexCall_Handler, 408 ServerStreams: true, 409 ClientStreams: true, 410 }, 411 { 412 StreamName: "ClientStreamCall", 413 Handler: _TestService_ClientStreamCall_Handler, 414 ClientStreams: true, 415 }, 416 { 417 StreamName: "ServerStreamCall", 418 Handler: _TestService_ServerStreamCall_Handler, 419 ServerStreams: true, 420 }, 421 }, 422 Metadata: "grpc_testing/test.proto", 423} 424