vendor/google.golang.org/grpc/benchmark/grpc_testing/services.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: services.proto
   3
   4 package grpc_testing
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9
  10 import (
  11         context "golang.org/x/net/context"
  12         grpc "google.golang.org/grpc"
  13 )
  14
  15 // Reference imports to suppress errors if they are not otherwise used.
  16 var _ = proto.Marshal
  17 var _ = fmt.Errorf
  18 var _ = math.Inf
  19
  20 // Reference imports to suppress errors if they are not otherwise used.
  21 var _ context.Context
  22 var _ grpc.ClientConn
  23
  24 // This is a compile-time assertion to ensure that this generated file
  25 // is compatible with the grpc package it is being compiled against.
  26 const _ = grpc.SupportPackageIsVersion4
  27
  28 // Client API for BenchmarkService service
  29
  30 type BenchmarkServiceClient interface {
  31         // One request followed by one response.
  32         // The server returns the client payload as-is.
  33         UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
  34         // One request followed by one response.
  35         // The server returns the client payload as-is.
  36         StreamingCall(ctx context.Context, opts ...grpc.CallOption) (BenchmarkService_StreamingCallClient, error)
  37 }
  38
  39 type benchmarkServiceClient struct {
  40         cc *grpc.ClientConn
  41 }
  42
  43 func NewBenchmarkServiceClient(cc *grpc.ClientConn) BenchmarkServiceClient {
  44         return &benchmarkServiceClient{cc}
  45 }
  46
  47 func (c *benchmarkServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
  48         out := new(SimpleResponse)
  49         err := grpc.Invoke(ctx, "/grpc.testing.BenchmarkService/UnaryCall", in, out, c.cc, opts...)
  50         if err != nil {
  51                 return nil, err
  52         }
  53         return out, nil
  54 }
  55
  56 func (c *benchmarkServiceClient) StreamingCall(ctx context.Context, opts ...grpc.CallOption) (BenchmarkService_StreamingCallClient, error) {
  57         stream, err := grpc.NewClientStream(ctx, &_BenchmarkService_serviceDesc.Streams[0], c.cc, "/grpc.testing.BenchmarkService/StreamingCall", opts...)
  58         if err != nil {
  59                 return nil, err
  60         }
  61         x := &benchmarkServiceStreamingCallClient{stream}
  62         return x, nil
  63 }
  64
  65 type BenchmarkService_StreamingCallClient interface {
  66         Send(*SimpleRequest) error
  67         Recv() (*SimpleResponse, error)
  68         grpc.ClientStream
  69 }
  70
  71 type benchmarkServiceStreamingCallClient struct {
  72         grpc.ClientStream
  73 }
  74
  75 func (x *benchmarkServiceStreamingCallClient) Send(m *SimpleRequest) error {
  76         return x.ClientStream.SendMsg(m)
  77 }
  78
  79 func (x *benchmarkServiceStreamingCallClient) Recv() (*SimpleResponse, error) {
  80         m := new(SimpleResponse)
  81         if err := x.ClientStream.RecvMsg(m); err != nil {
  82                 return nil, err
  83         }
  84         return m, nil
  85 }
  86
  87 // Server API for BenchmarkService service
  88
  89 type BenchmarkServiceServer interface {
  90         // One request followed by one response.
  91         // The server returns the client payload as-is.
  92         UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
  93         // One request followed by one response.
  94         // The server returns the client payload as-is.
  95         StreamingCall(BenchmarkService_StreamingCallServer) error
  96 }
  97
  98 func RegisterBenchmarkServiceServer(s *grpc.Server, srv BenchmarkServiceServer) {
  99         s.RegisterService(&_BenchmarkService_serviceDesc, srv)
 100 }
 101
 102 func _BenchmarkService_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 103         in := new(SimpleRequest)
 104         if err := dec(in); err != nil {
 105                 return nil, err
 106         }
 107         if interceptor == nil {
 108                 return srv.(BenchmarkServiceServer).UnaryCall(ctx, in)
 109         }
 110         info := &grpc.UnaryServerInfo{
 111                 Server:     srv,
 112                 FullMethod: "/grpc.testing.BenchmarkService/UnaryCall",
 113         }
 114         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 115                 return srv.(BenchmarkServiceServer).UnaryCall(ctx, req.(*SimpleRequest))
 116         }
 117         return interceptor(ctx, in, info, handler)
 118 }
 119
 120 func _BenchmarkService_StreamingCall_Handler(srv interface{}, stream grpc.ServerStream) error {
 121         return srv.(BenchmarkServiceServer).StreamingCall(&benchmarkServiceStreamingCallServer{stream})
 122 }
 123
 124 type BenchmarkService_StreamingCallServer interface {
 125         Send(*SimpleResponse) error
 126         Recv() (*SimpleRequest, error)
 127         grpc.ServerStream
 128 }
 129
 130 type benchmarkServiceStreamingCallServer struct {
 131         grpc.ServerStream
 132 }
 133
 134 func (x *benchmarkServiceStreamingCallServer) Send(m *SimpleResponse) error {
 135         return x.ServerStream.SendMsg(m)
 136 }
 137
 138 func (x *benchmarkServiceStreamingCallServer) Recv() (*SimpleRequest, error) {
 139         m := new(SimpleRequest)
 140         if err := x.ServerStream.RecvMsg(m); err != nil {
 141                 return nil, err
 142         }
 143         return m, nil
 144 }
 145
 146 var _BenchmarkService_serviceDesc = grpc.ServiceDesc{
 147         ServiceName: "grpc.testing.BenchmarkService",
 148         HandlerType: (*BenchmarkServiceServer)(nil),
 149         Methods: []grpc.MethodDesc{
 150                 {
 151                         MethodName: "UnaryCall",
 152                         Handler:    _BenchmarkService_UnaryCall_Handler,
 153                 },
 154         },
 155         Streams: []grpc.StreamDesc{
 156                 {
 157                         StreamName:    "StreamingCall",
 158                         Handler:       _BenchmarkService_StreamingCall_Handler,
 159                         ServerStreams: true,
 160                         ClientStreams: true,
 161                 },
 162         },
 163         Metadata: "services.proto",
 164 }
 165
 166 // Client API for WorkerService service
 167
 168 type WorkerServiceClient interface {
 169         // Start server with specified workload.
 170         // First request sent specifies the ServerConfig followed by ServerStatus
 171         // response. After that, a "Mark" can be sent anytime to request the latest
 172         // stats. Closing the stream will initiate shutdown of the test server
 173         // and once the shutdown has finished, the OK status is sent to terminate
 174         // this RPC.
 175         RunServer(ctx context.Context, opts ...grpc.CallOption) (WorkerService_RunServerClient, error)
 176         // Start client with specified workload.
 177         // First request sent specifies the ClientConfig followed by ClientStatus
 178         // response. After that, a "Mark" can be sent anytime to request the latest
 179         // stats. Closing the stream will initiate shutdown of the test client
 180         // and once the shutdown has finished, the OK status is sent to terminate
 181         // this RPC.
 182         RunClient(ctx context.Context, opts ...grpc.CallOption) (WorkerService_RunClientClient, error)
 183         // Just return the core count - unary call
 184         CoreCount(ctx context.Context, in *CoreRequest, opts ...grpc.CallOption) (*CoreResponse, error)
 185         // Quit this worker
 186         QuitWorker(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Void, error)
 187 }
 188
 189 type workerServiceClient struct {
 190         cc *grpc.ClientConn
 191 }
 192
 193 func NewWorkerServiceClient(cc *grpc.ClientConn) WorkerServiceClient {
 194         return &workerServiceClient{cc}
 195 }
 196
 197 func (c *workerServiceClient) RunServer(ctx context.Context, opts ...grpc.CallOption) (WorkerService_RunServerClient, error) {
 198         stream, err := grpc.NewClientStream(ctx, &_WorkerService_serviceDesc.Streams[0], c.cc, "/grpc.testing.WorkerService/RunServer", opts...)
 199         if err != nil {
 200                 return nil, err
 201         }
 202         x := &workerServiceRunServerClient{stream}
 203         return x, nil
 204 }
 205
 206 type WorkerService_RunServerClient interface {
 207         Send(*ServerArgs) error
 208         Recv() (*ServerStatus, error)
 209         grpc.ClientStream
 210 }
 211
 212 type workerServiceRunServerClient struct {
 213         grpc.ClientStream
 214 }
 215
 216 func (x *workerServiceRunServerClient) Send(m *ServerArgs) error {
 217         return x.ClientStream.SendMsg(m)
 218 }
 219
 220 func (x *workerServiceRunServerClient) Recv() (*ServerStatus, error) {
 221         m := new(ServerStatus)
 222         if err := x.ClientStream.RecvMsg(m); err != nil {
 223                 return nil, err
 224         }
 225         return m, nil
 226 }
 227
 228 func (c *workerServiceClient) RunClient(ctx context.Context, opts ...grpc.CallOption) (WorkerService_RunClientClient, error) {
 229         stream, err := grpc.NewClientStream(ctx, &_WorkerService_serviceDesc.Streams[1], c.cc, "/grpc.testing.WorkerService/RunClient", opts...)
 230         if err != nil {
 231                 return nil, err
 232         }
 233         x := &workerServiceRunClientClient{stream}
 234         return x, nil
 235 }
 236
 237 type WorkerService_RunClientClient interface {
 238         Send(*ClientArgs) error
 239         Recv() (*ClientStatus, error)
 240         grpc.ClientStream
 241 }
 242
 243 type workerServiceRunClientClient struct {
 244         grpc.ClientStream
 245 }
 246
 247 func (x *workerServiceRunClientClient) Send(m *ClientArgs) error {
 248         return x.ClientStream.SendMsg(m)
 249 }
 250
 251 func (x *workerServiceRunClientClient) Recv() (*ClientStatus, error) {
 252         m := new(ClientStatus)
 253         if err := x.ClientStream.RecvMsg(m); err != nil {
 254                 return nil, err
 255         }
 256         return m, nil
 257 }
 258
 259 func (c *workerServiceClient) CoreCount(ctx context.Context, in *CoreRequest, opts ...grpc.CallOption) (*CoreResponse, error) {
 260         out := new(CoreResponse)
 261         err := grpc.Invoke(ctx, "/grpc.testing.WorkerService/CoreCount", in, out, c.cc, opts...)
 262         if err != nil {
 263                 return nil, err
 264         }
 265         return out, nil
 266 }
 267
 268 func (c *workerServiceClient) QuitWorker(ctx context.Context, in *Void, opts ...grpc.CallOption) (*Void, error) {
 269         out := new(Void)
 270         err := grpc.Invoke(ctx, "/grpc.testing.WorkerService/QuitWorker", in, out, c.cc, opts...)
 271         if err != nil {
 272                 return nil, err
 273         }
 274         return out, nil
 275 }
 276
 277 // Server API for WorkerService service
 278
 279 type WorkerServiceServer interface {
 280         // Start server with specified workload.
 281         // First request sent specifies the ServerConfig followed by ServerStatus
 282         // response. After that, a "Mark" can be sent anytime to request the latest
 283         // stats. Closing the stream will initiate shutdown of the test server
 284         // and once the shutdown has finished, the OK status is sent to terminate
 285         // this RPC.
 286         RunServer(WorkerService_RunServerServer) error
 287         // Start client with specified workload.
 288         // First request sent specifies the ClientConfig followed by ClientStatus
 289         // response. After that, a "Mark" can be sent anytime to request the latest
 290         // stats. Closing the stream will initiate shutdown of the test client
 291         // and once the shutdown has finished, the OK status is sent to terminate
 292         // this RPC.
 293         RunClient(WorkerService_RunClientServer) error
 294         // Just return the core count - unary call
 295         CoreCount(context.Context, *CoreRequest) (*CoreResponse, error)
 296         // Quit this worker
 297         QuitWorker(context.Context, *Void) (*Void, error)
 298 }
 299
 300 func RegisterWorkerServiceServer(s *grpc.Server, srv WorkerServiceServer) {
 301         s.RegisterService(&_WorkerService_serviceDesc, srv)
 302 }
 303
 304 func _WorkerService_RunServer_Handler(srv interface{}, stream grpc.ServerStream) error {
 305         return srv.(WorkerServiceServer).RunServer(&workerServiceRunServerServer{stream})
 306 }
 307
 308 type WorkerService_RunServerServer interface {
 309         Send(*ServerStatus) error
 310         Recv() (*ServerArgs, error)
 311         grpc.ServerStream
 312 }
 313
 314 type workerServiceRunServerServer struct {
 315         grpc.ServerStream
 316 }
 317
 318 func (x *workerServiceRunServerServer) Send(m *ServerStatus) error {
 319         return x.ServerStream.SendMsg(m)
 320 }
 321
 322 func (x *workerServiceRunServerServer) Recv() (*ServerArgs, error) {
 323         m := new(ServerArgs)
 324         if err := x.ServerStream.RecvMsg(m); err != nil {
 325                 return nil, err
 326         }
 327         return m, nil
 328 }
 329
 330 func _WorkerService_RunClient_Handler(srv interface{}, stream grpc.ServerStream) error {
 331         return srv.(WorkerServiceServer).RunClient(&workerServiceRunClientServer{stream})
 332 }
 333
 334 type WorkerService_RunClientServer interface {
 335         Send(*ClientStatus) error
 336         Recv() (*ClientArgs, error)
 337         grpc.ServerStream
 338 }
 339
 340 type workerServiceRunClientServer struct {
 341         grpc.ServerStream
 342 }
 343
 344 func (x *workerServiceRunClientServer) Send(m *ClientStatus) error {
 345         return x.ServerStream.SendMsg(m)
 346 }
 347
 348 func (x *workerServiceRunClientServer) Recv() (*ClientArgs, error) {
 349         m := new(ClientArgs)
 350         if err := x.ServerStream.RecvMsg(m); err != nil {
 351                 return nil, err
 352         }
 353         return m, nil
 354 }
 355
 356 func _WorkerService_CoreCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 357         in := new(CoreRequest)
 358         if err := dec(in); err != nil {
 359                 return nil, err
 360         }
 361         if interceptor == nil {
 362                 return srv.(WorkerServiceServer).CoreCount(ctx, in)
 363         }
 364         info := &grpc.UnaryServerInfo{
 365                 Server:     srv,
 366                 FullMethod: "/grpc.testing.WorkerService/CoreCount",
 367         }
 368         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 369                 return srv.(WorkerServiceServer).CoreCount(ctx, req.(*CoreRequest))
 370         }
 371         return interceptor(ctx, in, info, handler)
 372 }
 373
 374 func _WorkerService_QuitWorker_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 375         in := new(Void)
 376         if err := dec(in); err != nil {
 377                 return nil, err
 378         }
 379         if interceptor == nil {
 380                 return srv.(WorkerServiceServer).QuitWorker(ctx, in)
 381         }
 382         info := &grpc.UnaryServerInfo{
 383                 Server:     srv,
 384                 FullMethod: "/grpc.testing.WorkerService/QuitWorker",
 385         }
 386         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 387                 return srv.(WorkerServiceServer).QuitWorker(ctx, req.(*Void))
 388         }
 389         return interceptor(ctx, in, info, handler)
 390 }
 391
 392 var _WorkerService_serviceDesc = grpc.ServiceDesc{
 393         ServiceName: "grpc.testing.WorkerService",
 394         HandlerType: (*WorkerServiceServer)(nil),
 395         Methods: []grpc.MethodDesc{
 396                 {
 397                         MethodName: "CoreCount",
 398                         Handler:    _WorkerService_CoreCount_Handler,
 399                 },
 400                 {
 401                         MethodName: "QuitWorker",
 402                         Handler:    _WorkerService_QuitWorker_Handler,
 403                 },
 404         },
 405         Streams: []grpc.StreamDesc{
 406                 {
 407                         StreamName:    "RunServer",
 408                         Handler:       _WorkerService_RunServer_Handler,
 409                         ServerStreams: true,
 410                         ClientStreams: true,
 411                 },
 412                 {
 413                         StreamName:    "RunClient",
 414                         Handler:       _WorkerService_RunClient_Handler,
 415                         ServerStreams: true,
 416                         ClientStreams: true,
 417                 },
 418         },
 419         Metadata: "services.proto",
 420 }
 421
 422 func init() { proto.RegisterFile("services.proto", fileDescriptor3) }
 423
 424 var fileDescriptor3 = []byte{
 425         // 255 bytes of a gzipped FileDescriptorProto
 426         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x91, 0xc1, 0x4a, 0xc4, 0x30,
 427         0x10, 0x86, 0xa9, 0x07, 0xa1, 0xc1, 0x2e, 0x92, 0x93, 0x46, 0x1f, 0xc0, 0x53, 0x91, 0xd5, 0x17,
 428         0x70, 0x8b, 0x1e, 0x05, 0xb7, 0xa8, 0xe7, 0x58, 0x87, 0x1a, 0x36, 0xcd, 0xd4, 0x99, 0x89, 0xe0,
 429         0x93, 0xf8, 0x0e, 0x3e, 0xa5, 0xec, 0x66, 0x57, 0xd6, 0x92, 0x9b, 0xc7, 0xf9, 0xbf, 0xe1, 0x23,
 430         0x7f, 0x46, 0xcd, 0x18, 0xe8, 0xc3, 0x75, 0xc0, 0xf5, 0x48, 0x28, 0xa8, 0x8f, 0x7a, 0x1a, 0xbb,
 431         0x5a, 0x80, 0xc5, 0x85, 0xde, 0xcc, 0x06, 0x60, 0xb6, 0xfd, 0x8e, 0x9a, 0xaa, 0xc3, 0x20, 0x84,
 432         0x3e, 0x8d, 0xf3, 0xef, 0x42, 0x1d, 0x2f, 0x20, 0x74, 0x6f, 0x83, 0xa5, 0x55, 0x9b, 0x44, 0xfa,
 433         0x4e, 0x95, 0x8f, 0xc1, 0xd2, 0x67, 0x63, 0xbd, 0xd7, 0x67, 0xf5, 0xbe, 0xaf, 0x6e, 0xdd, 0x30,
 434         0x7a, 0x58, 0xc2, 0x7b, 0x04, 0x16, 0x73, 0x9e, 0x87, 0x3c, 0x62, 0x60, 0xd0, 0xf7, 0xaa, 0x6a,
 435         0x85, 0xc0, 0x0e, 0x2e, 0xf4, 0xff, 0x74, 0x5d, 0x14, 0x97, 0xc5, 0xfc, 0xeb, 0x40, 0x55, 0xcf,
 436         0x48, 0x2b, 0xa0, 0xdd, 0x4b, 0x6f, 0x55, 0xb9, 0x8c, 0x61, 0x3d, 0x01, 0xe9, 0x93, 0x89, 0x60,
 437         0x93, 0xde, 0x50, 0xcf, 0xc6, 0xe4, 0x48, 0x2b, 0x56, 0x22, 0xaf, 0xc5, 0x5b, 0x4d, 0xe3, 0x1d,
 438         0x04, 0x99, 0x6a, 0x52, 0x9a, 0xd3, 0x24, 0xb2, 0xa7, 0x59, 0xa8, 0xb2, 0x41, 0x82, 0x06, 0x63,
 439         0x10, 0x7d, 0x3a, 0x59, 0x46, 0xfa, 0x6d, 0x6a, 0x72, 0x68, 0xfb, 0x67, 0xd7, 0x4a, 0x3d, 0x44,
 440         0x27, 0xa9, 0xa6, 0xd6, 0x7f, 0x37, 0x9f, 0xd0, 0xbd, 0x9a, 0x4c, 0xf6, 0x72, 0xb8, 0xb9, 0xe6,
 441         0xd5, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3b, 0x84, 0x02, 0xe3, 0x0c, 0x02, 0x00, 0x00,
 442 }