github.com/kubeshop/testkube@v1.17.23/pkg/logs/pb/logs_grpc.pb.go (about) 1 // Code generated by protoc-gen-go-grpc. DO NOT EDIT. 2 // versions: 3 // - protoc-gen-go-grpc v1.3.0 4 // - protoc v3.19.4 5 // source: pkg/logs/pb/logs.proto 6 7 package pb 8 9 import ( 10 context "context" 11 grpc "google.golang.org/grpc" 12 codes "google.golang.org/grpc/codes" 13 status "google.golang.org/grpc/status" 14 ) 15 16 // This is a compile-time assertion to ensure that this generated file 17 // is compatible with the grpc package it is being compiled against. 18 // Requires gRPC-Go v1.32.0 or later. 19 const _ = grpc.SupportPackageIsVersion7 20 21 const ( 22 LogsService_Logs_FullMethodName = "/logs.LogsService/Logs" 23 ) 24 25 // LogsServiceClient is the client API for LogsService service. 26 // 27 // 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. 28 type LogsServiceClient interface { 29 Logs(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (LogsService_LogsClient, error) 30 } 31 32 type logsServiceClient struct { 33 cc grpc.ClientConnInterface 34 } 35 36 func NewLogsServiceClient(cc grpc.ClientConnInterface) LogsServiceClient { 37 return &logsServiceClient{cc} 38 } 39 40 func (c *logsServiceClient) Logs(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (LogsService_LogsClient, error) { 41 stream, err := c.cc.NewStream(ctx, &LogsService_ServiceDesc.Streams[0], LogsService_Logs_FullMethodName, opts...) 42 if err != nil { 43 return nil, err 44 } 45 x := &logsServiceLogsClient{stream} 46 if err := x.ClientStream.SendMsg(in); err != nil { 47 return nil, err 48 } 49 if err := x.ClientStream.CloseSend(); err != nil { 50 return nil, err 51 } 52 return x, nil 53 } 54 55 type LogsService_LogsClient interface { 56 Recv() (*Log, error) 57 grpc.ClientStream 58 } 59 60 type logsServiceLogsClient struct { 61 grpc.ClientStream 62 } 63 64 func (x *logsServiceLogsClient) Recv() (*Log, error) { 65 m := new(Log) 66 if err := x.ClientStream.RecvMsg(m); err != nil { 67 return nil, err 68 } 69 return m, nil 70 } 71 72 // LogsServiceServer is the server API for LogsService service. 73 // All implementations must embed UnimplementedLogsServiceServer 74 // for forward compatibility 75 type LogsServiceServer interface { 76 Logs(*LogRequest, LogsService_LogsServer) error 77 mustEmbedUnimplementedLogsServiceServer() 78 } 79 80 // UnimplementedLogsServiceServer must be embedded to have forward compatible implementations. 81 type UnimplementedLogsServiceServer struct { 82 } 83 84 func (UnimplementedLogsServiceServer) Logs(*LogRequest, LogsService_LogsServer) error { 85 return status.Errorf(codes.Unimplemented, "method Logs not implemented") 86 } 87 func (UnimplementedLogsServiceServer) mustEmbedUnimplementedLogsServiceServer() {} 88 89 // UnsafeLogsServiceServer may be embedded to opt out of forward compatibility for this service. 90 // Use of this interface is not recommended, as added methods to LogsServiceServer will 91 // result in compilation errors. 92 type UnsafeLogsServiceServer interface { 93 mustEmbedUnimplementedLogsServiceServer() 94 } 95 96 func RegisterLogsServiceServer(s grpc.ServiceRegistrar, srv LogsServiceServer) { 97 s.RegisterService(&LogsService_ServiceDesc, srv) 98 } 99 100 func _LogsService_Logs_Handler(srv interface{}, stream grpc.ServerStream) error { 101 m := new(LogRequest) 102 if err := stream.RecvMsg(m); err != nil { 103 return err 104 } 105 return srv.(LogsServiceServer).Logs(m, &logsServiceLogsServer{stream}) 106 } 107 108 type LogsService_LogsServer interface { 109 Send(*Log) error 110 grpc.ServerStream 111 } 112 113 type logsServiceLogsServer struct { 114 grpc.ServerStream 115 } 116 117 func (x *logsServiceLogsServer) Send(m *Log) error { 118 return x.ServerStream.SendMsg(m) 119 } 120 121 // LogsService_ServiceDesc is the grpc.ServiceDesc for LogsService service. 122 // It's only intended for direct use with grpc.RegisterService, 123 // and not to be introspected or modified (even as a copy) 124 var LogsService_ServiceDesc = grpc.ServiceDesc{ 125 ServiceName: "logs.LogsService", 126 HandlerType: (*LogsServiceServer)(nil), 127 Methods: []grpc.MethodDesc{}, 128 Streams: []grpc.StreamDesc{ 129 { 130 StreamName: "Logs", 131 Handler: _LogsService_Logs_Handler, 132 ServerStreams: true, 133 }, 134 }, 135 Metadata: "pkg/logs/pb/logs.proto", 136 } 137 138 const ( 139 CloudLogsService_Stream_FullMethodName = "/logs.CloudLogsService/Stream" 140 CloudLogsService_Logs_FullMethodName = "/logs.CloudLogsService/Logs" 141 ) 142 143 // CloudLogsServiceClient is the client API for CloudLogsService service. 144 // 145 // 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. 146 type CloudLogsServiceClient interface { 147 Stream(ctx context.Context, opts ...grpc.CallOption) (CloudLogsService_StreamClient, error) 148 Logs(ctx context.Context, in *CloudLogRequest, opts ...grpc.CallOption) (CloudLogsService_LogsClient, error) 149 } 150 151 type cloudLogsServiceClient struct { 152 cc grpc.ClientConnInterface 153 } 154 155 func NewCloudLogsServiceClient(cc grpc.ClientConnInterface) CloudLogsServiceClient { 156 return &cloudLogsServiceClient{cc} 157 } 158 159 func (c *cloudLogsServiceClient) Stream(ctx context.Context, opts ...grpc.CallOption) (CloudLogsService_StreamClient, error) { 160 stream, err := c.cc.NewStream(ctx, &CloudLogsService_ServiceDesc.Streams[0], CloudLogsService_Stream_FullMethodName, opts...) 161 if err != nil { 162 return nil, err 163 } 164 x := &cloudLogsServiceStreamClient{stream} 165 return x, nil 166 } 167 168 type CloudLogsService_StreamClient interface { 169 Send(*Log) error 170 CloseAndRecv() (*StreamResponse, error) 171 grpc.ClientStream 172 } 173 174 type cloudLogsServiceStreamClient struct { 175 grpc.ClientStream 176 } 177 178 func (x *cloudLogsServiceStreamClient) Send(m *Log) error { 179 return x.ClientStream.SendMsg(m) 180 } 181 182 func (x *cloudLogsServiceStreamClient) CloseAndRecv() (*StreamResponse, error) { 183 if err := x.ClientStream.CloseSend(); err != nil { 184 return nil, err 185 } 186 m := new(StreamResponse) 187 if err := x.ClientStream.RecvMsg(m); err != nil { 188 return nil, err 189 } 190 return m, nil 191 } 192 193 func (c *cloudLogsServiceClient) Logs(ctx context.Context, in *CloudLogRequest, opts ...grpc.CallOption) (CloudLogsService_LogsClient, error) { 194 stream, err := c.cc.NewStream(ctx, &CloudLogsService_ServiceDesc.Streams[1], CloudLogsService_Logs_FullMethodName, opts...) 195 if err != nil { 196 return nil, err 197 } 198 x := &cloudLogsServiceLogsClient{stream} 199 if err := x.ClientStream.SendMsg(in); err != nil { 200 return nil, err 201 } 202 if err := x.ClientStream.CloseSend(); err != nil { 203 return nil, err 204 } 205 return x, nil 206 } 207 208 type CloudLogsService_LogsClient interface { 209 Recv() (*Log, error) 210 grpc.ClientStream 211 } 212 213 type cloudLogsServiceLogsClient struct { 214 grpc.ClientStream 215 } 216 217 func (x *cloudLogsServiceLogsClient) Recv() (*Log, error) { 218 m := new(Log) 219 if err := x.ClientStream.RecvMsg(m); err != nil { 220 return nil, err 221 } 222 return m, nil 223 } 224 225 // CloudLogsServiceServer is the server API for CloudLogsService service. 226 // All implementations must embed UnimplementedCloudLogsServiceServer 227 // for forward compatibility 228 type CloudLogsServiceServer interface { 229 Stream(CloudLogsService_StreamServer) error 230 Logs(*CloudLogRequest, CloudLogsService_LogsServer) error 231 mustEmbedUnimplementedCloudLogsServiceServer() 232 } 233 234 // UnimplementedCloudLogsServiceServer must be embedded to have forward compatible implementations. 235 type UnimplementedCloudLogsServiceServer struct { 236 } 237 238 func (UnimplementedCloudLogsServiceServer) Stream(CloudLogsService_StreamServer) error { 239 return status.Errorf(codes.Unimplemented, "method Stream not implemented") 240 } 241 func (UnimplementedCloudLogsServiceServer) Logs(*CloudLogRequest, CloudLogsService_LogsServer) error { 242 return status.Errorf(codes.Unimplemented, "method Logs not implemented") 243 } 244 func (UnimplementedCloudLogsServiceServer) mustEmbedUnimplementedCloudLogsServiceServer() {} 245 246 // UnsafeCloudLogsServiceServer may be embedded to opt out of forward compatibility for this service. 247 // Use of this interface is not recommended, as added methods to CloudLogsServiceServer will 248 // result in compilation errors. 249 type UnsafeCloudLogsServiceServer interface { 250 mustEmbedUnimplementedCloudLogsServiceServer() 251 } 252 253 func RegisterCloudLogsServiceServer(s grpc.ServiceRegistrar, srv CloudLogsServiceServer) { 254 s.RegisterService(&CloudLogsService_ServiceDesc, srv) 255 } 256 257 func _CloudLogsService_Stream_Handler(srv interface{}, stream grpc.ServerStream) error { 258 return srv.(CloudLogsServiceServer).Stream(&cloudLogsServiceStreamServer{stream}) 259 } 260 261 type CloudLogsService_StreamServer interface { 262 SendAndClose(*StreamResponse) error 263 Recv() (*Log, error) 264 grpc.ServerStream 265 } 266 267 type cloudLogsServiceStreamServer struct { 268 grpc.ServerStream 269 } 270 271 func (x *cloudLogsServiceStreamServer) SendAndClose(m *StreamResponse) error { 272 return x.ServerStream.SendMsg(m) 273 } 274 275 func (x *cloudLogsServiceStreamServer) Recv() (*Log, error) { 276 m := new(Log) 277 if err := x.ServerStream.RecvMsg(m); err != nil { 278 return nil, err 279 } 280 return m, nil 281 } 282 283 func _CloudLogsService_Logs_Handler(srv interface{}, stream grpc.ServerStream) error { 284 m := new(CloudLogRequest) 285 if err := stream.RecvMsg(m); err != nil { 286 return err 287 } 288 return srv.(CloudLogsServiceServer).Logs(m, &cloudLogsServiceLogsServer{stream}) 289 } 290 291 type CloudLogsService_LogsServer interface { 292 Send(*Log) error 293 grpc.ServerStream 294 } 295 296 type cloudLogsServiceLogsServer struct { 297 grpc.ServerStream 298 } 299 300 func (x *cloudLogsServiceLogsServer) Send(m *Log) error { 301 return x.ServerStream.SendMsg(m) 302 } 303 304 // CloudLogsService_ServiceDesc is the grpc.ServiceDesc for CloudLogsService service. 305 // It's only intended for direct use with grpc.RegisterService, 306 // and not to be introspected or modified (even as a copy) 307 var CloudLogsService_ServiceDesc = grpc.ServiceDesc{ 308 ServiceName: "logs.CloudLogsService", 309 HandlerType: (*CloudLogsServiceServer)(nil), 310 Methods: []grpc.MethodDesc{}, 311 Streams: []grpc.StreamDesc{ 312 { 313 StreamName: "Stream", 314 Handler: _CloudLogsService_Stream_Handler, 315 ClientStreams: true, 316 }, 317 { 318 StreamName: "Logs", 319 Handler: _CloudLogsService_Logs_Handler, 320 ServerStreams: true, 321 }, 322 }, 323 Metadata: "pkg/logs/pb/logs.proto", 324 }