1// Code generated by protoc-gen-go-grpc. DO NOT EDIT. 2 3package grpc_testing 4 5import ( 6 context "context" 7 grpc "google.golang.org/grpc" 8 codes "google.golang.org/grpc/codes" 9 status "google.golang.org/grpc/status" 10) 11 12// This is a compile-time assertion to ensure that this generated file 13// is compatible with the grpc package it is being compiled against. 14// Requires gRPC-Go v1.32.0 or later. 15const _ = grpc.SupportPackageIsVersion7 16 17// TestServiceClient is the client API for TestService service. 18// 19// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. 20type TestServiceClient interface { 21 // One empty request followed by one empty response. 22 EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) 23 // One request followed by one response. 24 UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) 25 // One request followed by one response. Response has cache control 26 // headers set such that a caching HTTP proxy (such as GFE) can 27 // satisfy subsequent requests. 28 CacheableUnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) 29 // One request followed by a sequence of responses (streamed download). 30 // The server returns the payload with client desired type and sizes. 31 StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) 32 // A sequence of requests followed by one response (streamed upload). 33 // The server returns the aggregated size of client payload as the result. 34 StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) 35 // A sequence of requests with each request served by the server immediately. 36 // As one request could lead to multiple responses, this interface 37 // demonstrates the idea of full duplexing. 38 FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) 39 // A sequence of requests followed by a sequence of responses. 40 // The server buffers all the client requests and then serves them in order. A 41 // stream of responses are returned to the client when the server starts with 42 // first request. 43 HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) 44 // The test server will not implement this method. It will be used 45 // to test the behavior when clients call unimplemented methods. 46 UnimplementedCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) 47} 48 49type testServiceClient struct { 50 cc grpc.ClientConnInterface 51} 52 53func NewTestServiceClient(cc grpc.ClientConnInterface) TestServiceClient { 54 return &testServiceClient{cc} 55} 56 57func (c *testServiceClient) EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) { 58 out := new(Empty) 59 err := c.cc.Invoke(ctx, "/grpc.testing.TestService/EmptyCall", in, out, opts...) 60 if err != nil { 61 return nil, err 62 } 63 return out, nil 64} 65 66func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) { 67 out := new(SimpleResponse) 68 err := c.cc.Invoke(ctx, "/grpc.testing.TestService/UnaryCall", in, out, opts...) 69 if err != nil { 70 return nil, err 71 } 72 return out, nil 73} 74 75func (c *testServiceClient) CacheableUnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) { 76 out := new(SimpleResponse) 77 err := c.cc.Invoke(ctx, "/grpc.testing.TestService/CacheableUnaryCall", in, out, opts...) 78 if err != nil { 79 return nil, err 80 } 81 return out, nil 82} 83 84func (c *testServiceClient) StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) { 85 stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[0], "/grpc.testing.TestService/StreamingOutputCall", opts...) 86 if err != nil { 87 return nil, err 88 } 89 x := &testServiceStreamingOutputCallClient{stream} 90 if err := x.ClientStream.SendMsg(in); err != nil { 91 return nil, err 92 } 93 if err := x.ClientStream.CloseSend(); err != nil { 94 return nil, err 95 } 96 return x, nil 97} 98 99type TestService_StreamingOutputCallClient interface { 100 Recv() (*StreamingOutputCallResponse, error) 101 grpc.ClientStream 102} 103 104type testServiceStreamingOutputCallClient struct { 105 grpc.ClientStream 106} 107 108func (x *testServiceStreamingOutputCallClient) Recv() (*StreamingOutputCallResponse, error) { 109 m := new(StreamingOutputCallResponse) 110 if err := x.ClientStream.RecvMsg(m); err != nil { 111 return nil, err 112 } 113 return m, nil 114} 115 116func (c *testServiceClient) StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) { 117 stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[1], "/grpc.testing.TestService/StreamingInputCall", opts...) 118 if err != nil { 119 return nil, err 120 } 121 x := &testServiceStreamingInputCallClient{stream} 122 return x, nil 123} 124 125type TestService_StreamingInputCallClient interface { 126 Send(*StreamingInputCallRequest) error 127 CloseAndRecv() (*StreamingInputCallResponse, error) 128 grpc.ClientStream 129} 130 131type testServiceStreamingInputCallClient struct { 132 grpc.ClientStream 133} 134 135func (x *testServiceStreamingInputCallClient) Send(m *StreamingInputCallRequest) error { 136 return x.ClientStream.SendMsg(m) 137} 138 139func (x *testServiceStreamingInputCallClient) CloseAndRecv() (*StreamingInputCallResponse, error) { 140 if err := x.ClientStream.CloseSend(); err != nil { 141 return nil, err 142 } 143 m := new(StreamingInputCallResponse) 144 if err := x.ClientStream.RecvMsg(m); err != nil { 145 return nil, err 146 } 147 return m, nil 148} 149 150func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) { 151 stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[2], "/grpc.testing.TestService/FullDuplexCall", opts...) 152 if err != nil { 153 return nil, err 154 } 155 x := &testServiceFullDuplexCallClient{stream} 156 return x, nil 157} 158 159type TestService_FullDuplexCallClient interface { 160 Send(*StreamingOutputCallRequest) error 161 Recv() (*StreamingOutputCallResponse, error) 162 grpc.ClientStream 163} 164 165type testServiceFullDuplexCallClient struct { 166 grpc.ClientStream 167} 168 169func (x *testServiceFullDuplexCallClient) Send(m *StreamingOutputCallRequest) error { 170 return x.ClientStream.SendMsg(m) 171} 172 173func (x *testServiceFullDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) { 174 m := new(StreamingOutputCallResponse) 175 if err := x.ClientStream.RecvMsg(m); err != nil { 176 return nil, err 177 } 178 return m, nil 179} 180 181func (c *testServiceClient) HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) { 182 stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[3], "/grpc.testing.TestService/HalfDuplexCall", opts...) 183 if err != nil { 184 return nil, err 185 } 186 x := &testServiceHalfDuplexCallClient{stream} 187 return x, nil 188} 189 190type TestService_HalfDuplexCallClient interface { 191 Send(*StreamingOutputCallRequest) error 192 Recv() (*StreamingOutputCallResponse, error) 193 grpc.ClientStream 194} 195 196type testServiceHalfDuplexCallClient struct { 197 grpc.ClientStream 198} 199 200func (x *testServiceHalfDuplexCallClient) Send(m *StreamingOutputCallRequest) error { 201 return x.ClientStream.SendMsg(m) 202} 203 204func (x *testServiceHalfDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) { 205 m := new(StreamingOutputCallResponse) 206 if err := x.ClientStream.RecvMsg(m); err != nil { 207 return nil, err 208 } 209 return m, nil 210} 211 212func (c *testServiceClient) UnimplementedCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) { 213 out := new(Empty) 214 err := c.cc.Invoke(ctx, "/grpc.testing.TestService/UnimplementedCall", in, out, opts...) 215 if err != nil { 216 return nil, err 217 } 218 return out, nil 219} 220 221// TestServiceServer is the server API for TestService service. 222// All implementations must embed UnimplementedTestServiceServer 223// for forward compatibility 224type TestServiceServer interface { 225 // One empty request followed by one empty response. 226 EmptyCall(context.Context, *Empty) (*Empty, error) 227 // One request followed by one response. 228 UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) 229 // One request followed by one response. Response has cache control 230 // headers set such that a caching HTTP proxy (such as GFE) can 231 // satisfy subsequent requests. 232 CacheableUnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) 233 // One request followed by a sequence of responses (streamed download). 234 // The server returns the payload with client desired type and sizes. 235 StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error 236 // A sequence of requests followed by one response (streamed upload). 237 // The server returns the aggregated size of client payload as the result. 238 StreamingInputCall(TestService_StreamingInputCallServer) error 239 // A sequence of requests with each request served by the server immediately. 240 // As one request could lead to multiple responses, this interface 241 // demonstrates the idea of full duplexing. 242 FullDuplexCall(TestService_FullDuplexCallServer) error 243 // A sequence of requests followed by a sequence of responses. 244 // The server buffers all the client requests and then serves them in order. A 245 // stream of responses are returned to the client when the server starts with 246 // first request. 247 HalfDuplexCall(TestService_HalfDuplexCallServer) error 248 // The test server will not implement this method. It will be used 249 // to test the behavior when clients call unimplemented methods. 250 UnimplementedCall(context.Context, *Empty) (*Empty, error) 251 mustEmbedUnimplementedTestServiceServer() 252} 253 254// UnimplementedTestServiceServer must be embedded to have forward compatible implementations. 255type UnimplementedTestServiceServer struct { 256} 257 258func (UnimplementedTestServiceServer) EmptyCall(context.Context, *Empty) (*Empty, error) { 259 return nil, status.Errorf(codes.Unimplemented, "method EmptyCall not implemented") 260} 261func (UnimplementedTestServiceServer) UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) { 262 return nil, status.Errorf(codes.Unimplemented, "method UnaryCall not implemented") 263} 264func (UnimplementedTestServiceServer) CacheableUnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) { 265 return nil, status.Errorf(codes.Unimplemented, "method CacheableUnaryCall not implemented") 266} 267func (UnimplementedTestServiceServer) StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error { 268 return status.Errorf(codes.Unimplemented, "method StreamingOutputCall not implemented") 269} 270func (UnimplementedTestServiceServer) StreamingInputCall(TestService_StreamingInputCallServer) error { 271 return status.Errorf(codes.Unimplemented, "method StreamingInputCall not implemented") 272} 273func (UnimplementedTestServiceServer) FullDuplexCall(TestService_FullDuplexCallServer) error { 274 return status.Errorf(codes.Unimplemented, "method FullDuplexCall not implemented") 275} 276func (UnimplementedTestServiceServer) HalfDuplexCall(TestService_HalfDuplexCallServer) error { 277 return status.Errorf(codes.Unimplemented, "method HalfDuplexCall not implemented") 278} 279func (UnimplementedTestServiceServer) UnimplementedCall(context.Context, *Empty) (*Empty, error) { 280 return nil, status.Errorf(codes.Unimplemented, "method UnimplementedCall not implemented") 281} 282func (UnimplementedTestServiceServer) mustEmbedUnimplementedTestServiceServer() {} 283 284// UnsafeTestServiceServer may be embedded to opt out of forward compatibility for this service. 285// Use of this interface is not recommended, as added methods to TestServiceServer will 286// result in compilation errors. 287type UnsafeTestServiceServer interface { 288 mustEmbedUnimplementedTestServiceServer() 289} 290 291func RegisterTestServiceServer(s grpc.ServiceRegistrar, srv TestServiceServer) { 292 s.RegisterService(&TestService_ServiceDesc, srv) 293} 294 295func _TestService_EmptyCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 296 in := new(Empty) 297 if err := dec(in); err != nil { 298 return nil, err 299 } 300 if interceptor == nil { 301 return srv.(TestServiceServer).EmptyCall(ctx, in) 302 } 303 info := &grpc.UnaryServerInfo{ 304 Server: srv, 305 FullMethod: "/grpc.testing.TestService/EmptyCall", 306 } 307 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 308 return srv.(TestServiceServer).EmptyCall(ctx, req.(*Empty)) 309 } 310 return interceptor(ctx, in, info, handler) 311} 312 313func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 314 in := new(SimpleRequest) 315 if err := dec(in); err != nil { 316 return nil, err 317 } 318 if interceptor == nil { 319 return srv.(TestServiceServer).UnaryCall(ctx, in) 320 } 321 info := &grpc.UnaryServerInfo{ 322 Server: srv, 323 FullMethod: "/grpc.testing.TestService/UnaryCall", 324 } 325 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 326 return srv.(TestServiceServer).UnaryCall(ctx, req.(*SimpleRequest)) 327 } 328 return interceptor(ctx, in, info, handler) 329} 330 331func _TestService_CacheableUnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 332 in := new(SimpleRequest) 333 if err := dec(in); err != nil { 334 return nil, err 335 } 336 if interceptor == nil { 337 return srv.(TestServiceServer).CacheableUnaryCall(ctx, in) 338 } 339 info := &grpc.UnaryServerInfo{ 340 Server: srv, 341 FullMethod: "/grpc.testing.TestService/CacheableUnaryCall", 342 } 343 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 344 return srv.(TestServiceServer).CacheableUnaryCall(ctx, req.(*SimpleRequest)) 345 } 346 return interceptor(ctx, in, info, handler) 347} 348 349func _TestService_StreamingOutputCall_Handler(srv interface{}, stream grpc.ServerStream) error { 350 m := new(StreamingOutputCallRequest) 351 if err := stream.RecvMsg(m); err != nil { 352 return err 353 } 354 return srv.(TestServiceServer).StreamingOutputCall(m, &testServiceStreamingOutputCallServer{stream}) 355} 356 357type TestService_StreamingOutputCallServer interface { 358 Send(*StreamingOutputCallResponse) error 359 grpc.ServerStream 360} 361 362type testServiceStreamingOutputCallServer struct { 363 grpc.ServerStream 364} 365 366func (x *testServiceStreamingOutputCallServer) Send(m *StreamingOutputCallResponse) error { 367 return x.ServerStream.SendMsg(m) 368} 369 370func _TestService_StreamingInputCall_Handler(srv interface{}, stream grpc.ServerStream) error { 371 return srv.(TestServiceServer).StreamingInputCall(&testServiceStreamingInputCallServer{stream}) 372} 373 374type TestService_StreamingInputCallServer interface { 375 SendAndClose(*StreamingInputCallResponse) error 376 Recv() (*StreamingInputCallRequest, error) 377 grpc.ServerStream 378} 379 380type testServiceStreamingInputCallServer struct { 381 grpc.ServerStream 382} 383 384func (x *testServiceStreamingInputCallServer) SendAndClose(m *StreamingInputCallResponse) error { 385 return x.ServerStream.SendMsg(m) 386} 387 388func (x *testServiceStreamingInputCallServer) Recv() (*StreamingInputCallRequest, error) { 389 m := new(StreamingInputCallRequest) 390 if err := x.ServerStream.RecvMsg(m); err != nil { 391 return nil, err 392 } 393 return m, nil 394} 395 396func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error { 397 return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream}) 398} 399 400type TestService_FullDuplexCallServer interface { 401 Send(*StreamingOutputCallResponse) error 402 Recv() (*StreamingOutputCallRequest, error) 403 grpc.ServerStream 404} 405 406type testServiceFullDuplexCallServer struct { 407 grpc.ServerStream 408} 409 410func (x *testServiceFullDuplexCallServer) Send(m *StreamingOutputCallResponse) error { 411 return x.ServerStream.SendMsg(m) 412} 413 414func (x *testServiceFullDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) { 415 m := new(StreamingOutputCallRequest) 416 if err := x.ServerStream.RecvMsg(m); err != nil { 417 return nil, err 418 } 419 return m, nil 420} 421 422func _TestService_HalfDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error { 423 return srv.(TestServiceServer).HalfDuplexCall(&testServiceHalfDuplexCallServer{stream}) 424} 425 426type TestService_HalfDuplexCallServer interface { 427 Send(*StreamingOutputCallResponse) error 428 Recv() (*StreamingOutputCallRequest, error) 429 grpc.ServerStream 430} 431 432type testServiceHalfDuplexCallServer struct { 433 grpc.ServerStream 434} 435 436func (x *testServiceHalfDuplexCallServer) Send(m *StreamingOutputCallResponse) error { 437 return x.ServerStream.SendMsg(m) 438} 439 440func (x *testServiceHalfDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) { 441 m := new(StreamingOutputCallRequest) 442 if err := x.ServerStream.RecvMsg(m); err != nil { 443 return nil, err 444 } 445 return m, nil 446} 447 448func _TestService_UnimplementedCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 449 in := new(Empty) 450 if err := dec(in); err != nil { 451 return nil, err 452 } 453 if interceptor == nil { 454 return srv.(TestServiceServer).UnimplementedCall(ctx, in) 455 } 456 info := &grpc.UnaryServerInfo{ 457 Server: srv, 458 FullMethod: "/grpc.testing.TestService/UnimplementedCall", 459 } 460 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 461 return srv.(TestServiceServer).UnimplementedCall(ctx, req.(*Empty)) 462 } 463 return interceptor(ctx, in, info, handler) 464} 465 466// TestService_ServiceDesc is the grpc.ServiceDesc for TestService service. 467// It's only intended for direct use with grpc.RegisterService, 468// and not to be introspected or modified (even as a copy) 469var TestService_ServiceDesc = grpc.ServiceDesc{ 470 ServiceName: "grpc.testing.TestService", 471 HandlerType: (*TestServiceServer)(nil), 472 Methods: []grpc.MethodDesc{ 473 { 474 MethodName: "EmptyCall", 475 Handler: _TestService_EmptyCall_Handler, 476 }, 477 { 478 MethodName: "UnaryCall", 479 Handler: _TestService_UnaryCall_Handler, 480 }, 481 { 482 MethodName: "CacheableUnaryCall", 483 Handler: _TestService_CacheableUnaryCall_Handler, 484 }, 485 { 486 MethodName: "UnimplementedCall", 487 Handler: _TestService_UnimplementedCall_Handler, 488 }, 489 }, 490 Streams: []grpc.StreamDesc{ 491 { 492 StreamName: "StreamingOutputCall", 493 Handler: _TestService_StreamingOutputCall_Handler, 494 ServerStreams: true, 495 }, 496 { 497 StreamName: "StreamingInputCall", 498 Handler: _TestService_StreamingInputCall_Handler, 499 ClientStreams: true, 500 }, 501 { 502 StreamName: "FullDuplexCall", 503 Handler: _TestService_FullDuplexCall_Handler, 504 ServerStreams: true, 505 ClientStreams: true, 506 }, 507 { 508 StreamName: "HalfDuplexCall", 509 Handler: _TestService_HalfDuplexCall_Handler, 510 ServerStreams: true, 511 ClientStreams: true, 512 }, 513 }, 514 Metadata: "grpc/testing/test.proto", 515} 516 517// UnimplementedServiceClient is the client API for UnimplementedService service. 518// 519// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. 520type UnimplementedServiceClient interface { 521 // A call that no server should implement 522 UnimplementedCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) 523} 524 525type unimplementedServiceClient struct { 526 cc grpc.ClientConnInterface 527} 528 529func NewUnimplementedServiceClient(cc grpc.ClientConnInterface) UnimplementedServiceClient { 530 return &unimplementedServiceClient{cc} 531} 532 533func (c *unimplementedServiceClient) UnimplementedCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) { 534 out := new(Empty) 535 err := c.cc.Invoke(ctx, "/grpc.testing.UnimplementedService/UnimplementedCall", in, out, opts...) 536 if err != nil { 537 return nil, err 538 } 539 return out, nil 540} 541 542// UnimplementedServiceServer is the server API for UnimplementedService service. 543// All implementations must embed UnimplementedUnimplementedServiceServer 544// for forward compatibility 545type UnimplementedServiceServer interface { 546 // A call that no server should implement 547 UnimplementedCall(context.Context, *Empty) (*Empty, error) 548 mustEmbedUnimplementedUnimplementedServiceServer() 549} 550 551// UnimplementedUnimplementedServiceServer must be embedded to have forward compatible implementations. 552type UnimplementedUnimplementedServiceServer struct { 553} 554 555func (UnimplementedUnimplementedServiceServer) UnimplementedCall(context.Context, *Empty) (*Empty, error) { 556 return nil, status.Errorf(codes.Unimplemented, "method UnimplementedCall not implemented") 557} 558func (UnimplementedUnimplementedServiceServer) mustEmbedUnimplementedUnimplementedServiceServer() {} 559 560// UnsafeUnimplementedServiceServer may be embedded to opt out of forward compatibility for this service. 561// Use of this interface is not recommended, as added methods to UnimplementedServiceServer will 562// result in compilation errors. 563type UnsafeUnimplementedServiceServer interface { 564 mustEmbedUnimplementedUnimplementedServiceServer() 565} 566 567func RegisterUnimplementedServiceServer(s grpc.ServiceRegistrar, srv UnimplementedServiceServer) { 568 s.RegisterService(&UnimplementedService_ServiceDesc, srv) 569} 570 571func _UnimplementedService_UnimplementedCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 572 in := new(Empty) 573 if err := dec(in); err != nil { 574 return nil, err 575 } 576 if interceptor == nil { 577 return srv.(UnimplementedServiceServer).UnimplementedCall(ctx, in) 578 } 579 info := &grpc.UnaryServerInfo{ 580 Server: srv, 581 FullMethod: "/grpc.testing.UnimplementedService/UnimplementedCall", 582 } 583 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 584 return srv.(UnimplementedServiceServer).UnimplementedCall(ctx, req.(*Empty)) 585 } 586 return interceptor(ctx, in, info, handler) 587} 588 589// UnimplementedService_ServiceDesc is the grpc.ServiceDesc for UnimplementedService service. 590// It's only intended for direct use with grpc.RegisterService, 591// and not to be introspected or modified (even as a copy) 592var UnimplementedService_ServiceDesc = grpc.ServiceDesc{ 593 ServiceName: "grpc.testing.UnimplementedService", 594 HandlerType: (*UnimplementedServiceServer)(nil), 595 Methods: []grpc.MethodDesc{ 596 { 597 MethodName: "UnimplementedCall", 598 Handler: _UnimplementedService_UnimplementedCall_Handler, 599 }, 600 }, 601 Streams: []grpc.StreamDesc{}, 602 Metadata: "grpc/testing/test.proto", 603} 604 605// ReconnectServiceClient is the client API for ReconnectService service. 606// 607// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. 608type ReconnectServiceClient interface { 609 Start(ctx context.Context, in *ReconnectParams, opts ...grpc.CallOption) (*Empty, error) 610 Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ReconnectInfo, error) 611} 612 613type reconnectServiceClient struct { 614 cc grpc.ClientConnInterface 615} 616 617func NewReconnectServiceClient(cc grpc.ClientConnInterface) ReconnectServiceClient { 618 return &reconnectServiceClient{cc} 619} 620 621func (c *reconnectServiceClient) Start(ctx context.Context, in *ReconnectParams, opts ...grpc.CallOption) (*Empty, error) { 622 out := new(Empty) 623 err := c.cc.Invoke(ctx, "/grpc.testing.ReconnectService/Start", in, out, opts...) 624 if err != nil { 625 return nil, err 626 } 627 return out, nil 628} 629 630func (c *reconnectServiceClient) Stop(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ReconnectInfo, error) { 631 out := new(ReconnectInfo) 632 err := c.cc.Invoke(ctx, "/grpc.testing.ReconnectService/Stop", in, out, opts...) 633 if err != nil { 634 return nil, err 635 } 636 return out, nil 637} 638 639// ReconnectServiceServer is the server API for ReconnectService service. 640// All implementations must embed UnimplementedReconnectServiceServer 641// for forward compatibility 642type ReconnectServiceServer interface { 643 Start(context.Context, *ReconnectParams) (*Empty, error) 644 Stop(context.Context, *Empty) (*ReconnectInfo, error) 645 mustEmbedUnimplementedReconnectServiceServer() 646} 647 648// UnimplementedReconnectServiceServer must be embedded to have forward compatible implementations. 649type UnimplementedReconnectServiceServer struct { 650} 651 652func (UnimplementedReconnectServiceServer) Start(context.Context, *ReconnectParams) (*Empty, error) { 653 return nil, status.Errorf(codes.Unimplemented, "method Start not implemented") 654} 655func (UnimplementedReconnectServiceServer) Stop(context.Context, *Empty) (*ReconnectInfo, error) { 656 return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented") 657} 658func (UnimplementedReconnectServiceServer) mustEmbedUnimplementedReconnectServiceServer() {} 659 660// UnsafeReconnectServiceServer may be embedded to opt out of forward compatibility for this service. 661// Use of this interface is not recommended, as added methods to ReconnectServiceServer will 662// result in compilation errors. 663type UnsafeReconnectServiceServer interface { 664 mustEmbedUnimplementedReconnectServiceServer() 665} 666 667func RegisterReconnectServiceServer(s grpc.ServiceRegistrar, srv ReconnectServiceServer) { 668 s.RegisterService(&ReconnectService_ServiceDesc, srv) 669} 670 671func _ReconnectService_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 672 in := new(ReconnectParams) 673 if err := dec(in); err != nil { 674 return nil, err 675 } 676 if interceptor == nil { 677 return srv.(ReconnectServiceServer).Start(ctx, in) 678 } 679 info := &grpc.UnaryServerInfo{ 680 Server: srv, 681 FullMethod: "/grpc.testing.ReconnectService/Start", 682 } 683 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 684 return srv.(ReconnectServiceServer).Start(ctx, req.(*ReconnectParams)) 685 } 686 return interceptor(ctx, in, info, handler) 687} 688 689func _ReconnectService_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 690 in := new(Empty) 691 if err := dec(in); err != nil { 692 return nil, err 693 } 694 if interceptor == nil { 695 return srv.(ReconnectServiceServer).Stop(ctx, in) 696 } 697 info := &grpc.UnaryServerInfo{ 698 Server: srv, 699 FullMethod: "/grpc.testing.ReconnectService/Stop", 700 } 701 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 702 return srv.(ReconnectServiceServer).Stop(ctx, req.(*Empty)) 703 } 704 return interceptor(ctx, in, info, handler) 705} 706 707// ReconnectService_ServiceDesc is the grpc.ServiceDesc for ReconnectService service. 708// It's only intended for direct use with grpc.RegisterService, 709// and not to be introspected or modified (even as a copy) 710var ReconnectService_ServiceDesc = grpc.ServiceDesc{ 711 ServiceName: "grpc.testing.ReconnectService", 712 HandlerType: (*ReconnectServiceServer)(nil), 713 Methods: []grpc.MethodDesc{ 714 { 715 MethodName: "Start", 716 Handler: _ReconnectService_Start_Handler, 717 }, 718 { 719 MethodName: "Stop", 720 Handler: _ReconnectService_Stop_Handler, 721 }, 722 }, 723 Streams: []grpc.StreamDesc{}, 724 Metadata: "grpc/testing/test.proto", 725} 726 727// LoadBalancerStatsServiceClient is the client API for LoadBalancerStatsService service. 728// 729// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. 730type LoadBalancerStatsServiceClient interface { 731 // Gets the backend distribution for RPCs sent by a test client. 732 GetClientStats(ctx context.Context, in *LoadBalancerStatsRequest, opts ...grpc.CallOption) (*LoadBalancerStatsResponse, error) 733 // Gets the accumulated stats for RPCs sent by a test client. 734 GetClientAccumulatedStats(ctx context.Context, in *LoadBalancerAccumulatedStatsRequest, opts ...grpc.CallOption) (*LoadBalancerAccumulatedStatsResponse, error) 735} 736 737type loadBalancerStatsServiceClient struct { 738 cc grpc.ClientConnInterface 739} 740 741func NewLoadBalancerStatsServiceClient(cc grpc.ClientConnInterface) LoadBalancerStatsServiceClient { 742 return &loadBalancerStatsServiceClient{cc} 743} 744 745func (c *loadBalancerStatsServiceClient) GetClientStats(ctx context.Context, in *LoadBalancerStatsRequest, opts ...grpc.CallOption) (*LoadBalancerStatsResponse, error) { 746 out := new(LoadBalancerStatsResponse) 747 err := c.cc.Invoke(ctx, "/grpc.testing.LoadBalancerStatsService/GetClientStats", in, out, opts...) 748 if err != nil { 749 return nil, err 750 } 751 return out, nil 752} 753 754func (c *loadBalancerStatsServiceClient) GetClientAccumulatedStats(ctx context.Context, in *LoadBalancerAccumulatedStatsRequest, opts ...grpc.CallOption) (*LoadBalancerAccumulatedStatsResponse, error) { 755 out := new(LoadBalancerAccumulatedStatsResponse) 756 err := c.cc.Invoke(ctx, "/grpc.testing.LoadBalancerStatsService/GetClientAccumulatedStats", in, out, opts...) 757 if err != nil { 758 return nil, err 759 } 760 return out, nil 761} 762 763// LoadBalancerStatsServiceServer is the server API for LoadBalancerStatsService service. 764// All implementations must embed UnimplementedLoadBalancerStatsServiceServer 765// for forward compatibility 766type LoadBalancerStatsServiceServer interface { 767 // Gets the backend distribution for RPCs sent by a test client. 768 GetClientStats(context.Context, *LoadBalancerStatsRequest) (*LoadBalancerStatsResponse, error) 769 // Gets the accumulated stats for RPCs sent by a test client. 770 GetClientAccumulatedStats(context.Context, *LoadBalancerAccumulatedStatsRequest) (*LoadBalancerAccumulatedStatsResponse, error) 771 mustEmbedUnimplementedLoadBalancerStatsServiceServer() 772} 773 774// UnimplementedLoadBalancerStatsServiceServer must be embedded to have forward compatible implementations. 775type UnimplementedLoadBalancerStatsServiceServer struct { 776} 777 778func (UnimplementedLoadBalancerStatsServiceServer) GetClientStats(context.Context, *LoadBalancerStatsRequest) (*LoadBalancerStatsResponse, error) { 779 return nil, status.Errorf(codes.Unimplemented, "method GetClientStats not implemented") 780} 781func (UnimplementedLoadBalancerStatsServiceServer) GetClientAccumulatedStats(context.Context, *LoadBalancerAccumulatedStatsRequest) (*LoadBalancerAccumulatedStatsResponse, error) { 782 return nil, status.Errorf(codes.Unimplemented, "method GetClientAccumulatedStats not implemented") 783} 784func (UnimplementedLoadBalancerStatsServiceServer) mustEmbedUnimplementedLoadBalancerStatsServiceServer() { 785} 786 787// UnsafeLoadBalancerStatsServiceServer may be embedded to opt out of forward compatibility for this service. 788// Use of this interface is not recommended, as added methods to LoadBalancerStatsServiceServer will 789// result in compilation errors. 790type UnsafeLoadBalancerStatsServiceServer interface { 791 mustEmbedUnimplementedLoadBalancerStatsServiceServer() 792} 793 794func RegisterLoadBalancerStatsServiceServer(s grpc.ServiceRegistrar, srv LoadBalancerStatsServiceServer) { 795 s.RegisterService(&LoadBalancerStatsService_ServiceDesc, srv) 796} 797 798func _LoadBalancerStatsService_GetClientStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 799 in := new(LoadBalancerStatsRequest) 800 if err := dec(in); err != nil { 801 return nil, err 802 } 803 if interceptor == nil { 804 return srv.(LoadBalancerStatsServiceServer).GetClientStats(ctx, in) 805 } 806 info := &grpc.UnaryServerInfo{ 807 Server: srv, 808 FullMethod: "/grpc.testing.LoadBalancerStatsService/GetClientStats", 809 } 810 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 811 return srv.(LoadBalancerStatsServiceServer).GetClientStats(ctx, req.(*LoadBalancerStatsRequest)) 812 } 813 return interceptor(ctx, in, info, handler) 814} 815 816func _LoadBalancerStatsService_GetClientAccumulatedStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 817 in := new(LoadBalancerAccumulatedStatsRequest) 818 if err := dec(in); err != nil { 819 return nil, err 820 } 821 if interceptor == nil { 822 return srv.(LoadBalancerStatsServiceServer).GetClientAccumulatedStats(ctx, in) 823 } 824 info := &grpc.UnaryServerInfo{ 825 Server: srv, 826 FullMethod: "/grpc.testing.LoadBalancerStatsService/GetClientAccumulatedStats", 827 } 828 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 829 return srv.(LoadBalancerStatsServiceServer).GetClientAccumulatedStats(ctx, req.(*LoadBalancerAccumulatedStatsRequest)) 830 } 831 return interceptor(ctx, in, info, handler) 832} 833 834// LoadBalancerStatsService_ServiceDesc is the grpc.ServiceDesc for LoadBalancerStatsService service. 835// It's only intended for direct use with grpc.RegisterService, 836// and not to be introspected or modified (even as a copy) 837var LoadBalancerStatsService_ServiceDesc = grpc.ServiceDesc{ 838 ServiceName: "grpc.testing.LoadBalancerStatsService", 839 HandlerType: (*LoadBalancerStatsServiceServer)(nil), 840 Methods: []grpc.MethodDesc{ 841 { 842 MethodName: "GetClientStats", 843 Handler: _LoadBalancerStatsService_GetClientStats_Handler, 844 }, 845 { 846 MethodName: "GetClientAccumulatedStats", 847 Handler: _LoadBalancerStatsService_GetClientAccumulatedStats_Handler, 848 }, 849 }, 850 Streams: []grpc.StreamDesc{}, 851 Metadata: "grpc/testing/test.proto", 852} 853 854// XdsUpdateHealthServiceClient is the client API for XdsUpdateHealthService service. 855// 856// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. 857type XdsUpdateHealthServiceClient interface { 858 SetServing(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) 859 SetNotServing(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) 860} 861 862type xdsUpdateHealthServiceClient struct { 863 cc grpc.ClientConnInterface 864} 865 866func NewXdsUpdateHealthServiceClient(cc grpc.ClientConnInterface) XdsUpdateHealthServiceClient { 867 return &xdsUpdateHealthServiceClient{cc} 868} 869 870func (c *xdsUpdateHealthServiceClient) SetServing(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) { 871 out := new(Empty) 872 err := c.cc.Invoke(ctx, "/grpc.testing.XdsUpdateHealthService/SetServing", in, out, opts...) 873 if err != nil { 874 return nil, err 875 } 876 return out, nil 877} 878 879func (c *xdsUpdateHealthServiceClient) SetNotServing(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) { 880 out := new(Empty) 881 err := c.cc.Invoke(ctx, "/grpc.testing.XdsUpdateHealthService/SetNotServing", in, out, opts...) 882 if err != nil { 883 return nil, err 884 } 885 return out, nil 886} 887 888// XdsUpdateHealthServiceServer is the server API for XdsUpdateHealthService service. 889// All implementations must embed UnimplementedXdsUpdateHealthServiceServer 890// for forward compatibility 891type XdsUpdateHealthServiceServer interface { 892 SetServing(context.Context, *Empty) (*Empty, error) 893 SetNotServing(context.Context, *Empty) (*Empty, error) 894 mustEmbedUnimplementedXdsUpdateHealthServiceServer() 895} 896 897// UnimplementedXdsUpdateHealthServiceServer must be embedded to have forward compatible implementations. 898type UnimplementedXdsUpdateHealthServiceServer struct { 899} 900 901func (UnimplementedXdsUpdateHealthServiceServer) SetServing(context.Context, *Empty) (*Empty, error) { 902 return nil, status.Errorf(codes.Unimplemented, "method SetServing not implemented") 903} 904func (UnimplementedXdsUpdateHealthServiceServer) SetNotServing(context.Context, *Empty) (*Empty, error) { 905 return nil, status.Errorf(codes.Unimplemented, "method SetNotServing not implemented") 906} 907func (UnimplementedXdsUpdateHealthServiceServer) mustEmbedUnimplementedXdsUpdateHealthServiceServer() { 908} 909 910// UnsafeXdsUpdateHealthServiceServer may be embedded to opt out of forward compatibility for this service. 911// Use of this interface is not recommended, as added methods to XdsUpdateHealthServiceServer will 912// result in compilation errors. 913type UnsafeXdsUpdateHealthServiceServer interface { 914 mustEmbedUnimplementedXdsUpdateHealthServiceServer() 915} 916 917func RegisterXdsUpdateHealthServiceServer(s grpc.ServiceRegistrar, srv XdsUpdateHealthServiceServer) { 918 s.RegisterService(&XdsUpdateHealthService_ServiceDesc, srv) 919} 920 921func _XdsUpdateHealthService_SetServing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 922 in := new(Empty) 923 if err := dec(in); err != nil { 924 return nil, err 925 } 926 if interceptor == nil { 927 return srv.(XdsUpdateHealthServiceServer).SetServing(ctx, in) 928 } 929 info := &grpc.UnaryServerInfo{ 930 Server: srv, 931 FullMethod: "/grpc.testing.XdsUpdateHealthService/SetServing", 932 } 933 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 934 return srv.(XdsUpdateHealthServiceServer).SetServing(ctx, req.(*Empty)) 935 } 936 return interceptor(ctx, in, info, handler) 937} 938 939func _XdsUpdateHealthService_SetNotServing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 940 in := new(Empty) 941 if err := dec(in); err != nil { 942 return nil, err 943 } 944 if interceptor == nil { 945 return srv.(XdsUpdateHealthServiceServer).SetNotServing(ctx, in) 946 } 947 info := &grpc.UnaryServerInfo{ 948 Server: srv, 949 FullMethod: "/grpc.testing.XdsUpdateHealthService/SetNotServing", 950 } 951 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 952 return srv.(XdsUpdateHealthServiceServer).SetNotServing(ctx, req.(*Empty)) 953 } 954 return interceptor(ctx, in, info, handler) 955} 956 957// XdsUpdateHealthService_ServiceDesc is the grpc.ServiceDesc for XdsUpdateHealthService service. 958// It's only intended for direct use with grpc.RegisterService, 959// and not to be introspected or modified (even as a copy) 960var XdsUpdateHealthService_ServiceDesc = grpc.ServiceDesc{ 961 ServiceName: "grpc.testing.XdsUpdateHealthService", 962 HandlerType: (*XdsUpdateHealthServiceServer)(nil), 963 Methods: []grpc.MethodDesc{ 964 { 965 MethodName: "SetServing", 966 Handler: _XdsUpdateHealthService_SetServing_Handler, 967 }, 968 { 969 MethodName: "SetNotServing", 970 Handler: _XdsUpdateHealthService_SetNotServing_Handler, 971 }, 972 }, 973 Streams: []grpc.StreamDesc{}, 974 Metadata: "grpc/testing/test.proto", 975} 976 977// XdsUpdateClientConfigureServiceClient is the client API for XdsUpdateClientConfigureService service. 978// 979// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. 980type XdsUpdateClientConfigureServiceClient interface { 981 // Update the tes client's configuration. 982 Configure(ctx context.Context, in *ClientConfigureRequest, opts ...grpc.CallOption) (*ClientConfigureResponse, error) 983} 984 985type xdsUpdateClientConfigureServiceClient struct { 986 cc grpc.ClientConnInterface 987} 988 989func NewXdsUpdateClientConfigureServiceClient(cc grpc.ClientConnInterface) XdsUpdateClientConfigureServiceClient { 990 return &xdsUpdateClientConfigureServiceClient{cc} 991} 992 993func (c *xdsUpdateClientConfigureServiceClient) Configure(ctx context.Context, in *ClientConfigureRequest, opts ...grpc.CallOption) (*ClientConfigureResponse, error) { 994 out := new(ClientConfigureResponse) 995 err := c.cc.Invoke(ctx, "/grpc.testing.XdsUpdateClientConfigureService/Configure", in, out, opts...) 996 if err != nil { 997 return nil, err 998 } 999 return out, nil 1000} 1001 1002// XdsUpdateClientConfigureServiceServer is the server API for XdsUpdateClientConfigureService service. 1003// All implementations must embed UnimplementedXdsUpdateClientConfigureServiceServer 1004// for forward compatibility 1005type XdsUpdateClientConfigureServiceServer interface { 1006 // Update the tes client's configuration. 1007 Configure(context.Context, *ClientConfigureRequest) (*ClientConfigureResponse, error) 1008 mustEmbedUnimplementedXdsUpdateClientConfigureServiceServer() 1009} 1010 1011// UnimplementedXdsUpdateClientConfigureServiceServer must be embedded to have forward compatible implementations. 1012type UnimplementedXdsUpdateClientConfigureServiceServer struct { 1013} 1014 1015func (UnimplementedXdsUpdateClientConfigureServiceServer) Configure(context.Context, *ClientConfigureRequest) (*ClientConfigureResponse, error) { 1016 return nil, status.Errorf(codes.Unimplemented, "method Configure not implemented") 1017} 1018func (UnimplementedXdsUpdateClientConfigureServiceServer) mustEmbedUnimplementedXdsUpdateClientConfigureServiceServer() { 1019} 1020 1021// UnsafeXdsUpdateClientConfigureServiceServer may be embedded to opt out of forward compatibility for this service. 1022// Use of this interface is not recommended, as added methods to XdsUpdateClientConfigureServiceServer will 1023// result in compilation errors. 1024type UnsafeXdsUpdateClientConfigureServiceServer interface { 1025 mustEmbedUnimplementedXdsUpdateClientConfigureServiceServer() 1026} 1027 1028func RegisterXdsUpdateClientConfigureServiceServer(s grpc.ServiceRegistrar, srv XdsUpdateClientConfigureServiceServer) { 1029 s.RegisterService(&XdsUpdateClientConfigureService_ServiceDesc, srv) 1030} 1031 1032func _XdsUpdateClientConfigureService_Configure_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 1033 in := new(ClientConfigureRequest) 1034 if err := dec(in); err != nil { 1035 return nil, err 1036 } 1037 if interceptor == nil { 1038 return srv.(XdsUpdateClientConfigureServiceServer).Configure(ctx, in) 1039 } 1040 info := &grpc.UnaryServerInfo{ 1041 Server: srv, 1042 FullMethod: "/grpc.testing.XdsUpdateClientConfigureService/Configure", 1043 } 1044 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 1045 return srv.(XdsUpdateClientConfigureServiceServer).Configure(ctx, req.(*ClientConfigureRequest)) 1046 } 1047 return interceptor(ctx, in, info, handler) 1048} 1049 1050// XdsUpdateClientConfigureService_ServiceDesc is the grpc.ServiceDesc for XdsUpdateClientConfigureService service. 1051// It's only intended for direct use with grpc.RegisterService, 1052// and not to be introspected or modified (even as a copy) 1053var XdsUpdateClientConfigureService_ServiceDesc = grpc.ServiceDesc{ 1054 ServiceName: "grpc.testing.XdsUpdateClientConfigureService", 1055 HandlerType: (*XdsUpdateClientConfigureServiceServer)(nil), 1056 Methods: []grpc.MethodDesc{ 1057 { 1058 MethodName: "Configure", 1059 Handler: _XdsUpdateClientConfigureService_Configure_Handler, 1060 }, 1061 }, 1062 Streams: []grpc.StreamDesc{}, 1063 Metadata: "grpc/testing/test.proto", 1064} 1065