github.com/cilium/cilium@v1.16.2/api/v1/recorder/recorder_grpc.pb.go (about)

     1  // SPDX-License-Identifier: Apache-2.0
     2  // Copyright Authors of Hubble
     3  
     4  // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
     5  // versions:
     6  // - protoc-gen-go-grpc v1.3.0
     7  // - protoc             v5.28.1
     8  // source: recorder/recorder.proto
     9  
    10  package recorder
    11  
    12  import (
    13  	context "context"
    14  	grpc "google.golang.org/grpc"
    15  	codes "google.golang.org/grpc/codes"
    16  	status "google.golang.org/grpc/status"
    17  )
    18  
    19  // This is a compile-time assertion to ensure that this generated file
    20  // is compatible with the grpc package it is being compiled against.
    21  // Requires gRPC-Go v1.62.0 or later.
    22  const _ = grpc.SupportPackageIsVersion8
    23  
    24  const (
    25  	Recorder_Record_FullMethodName = "/recorder.Recorder/Record"
    26  )
    27  
    28  // RecorderClient is the client API for Recorder service.
    29  //
    30  // 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.
    31  //
    32  // Recorder implements the Hubble module for capturing network packets
    33  type RecorderClient interface {
    34  	// Record can start and stop a single recording. The recording is
    35  	// automatically stopped if the client aborts this rpc call.
    36  	Record(ctx context.Context, opts ...grpc.CallOption) (Recorder_RecordClient, error)
    37  }
    38  
    39  type recorderClient struct {
    40  	cc grpc.ClientConnInterface
    41  }
    42  
    43  func NewRecorderClient(cc grpc.ClientConnInterface) RecorderClient {
    44  	return &recorderClient{cc}
    45  }
    46  
    47  func (c *recorderClient) Record(ctx context.Context, opts ...grpc.CallOption) (Recorder_RecordClient, error) {
    48  	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
    49  	stream, err := c.cc.NewStream(ctx, &Recorder_ServiceDesc.Streams[0], Recorder_Record_FullMethodName, cOpts...)
    50  	if err != nil {
    51  		return nil, err
    52  	}
    53  	x := &recorderRecordClient{ClientStream: stream}
    54  	return x, nil
    55  }
    56  
    57  type Recorder_RecordClient interface {
    58  	Send(*RecordRequest) error
    59  	Recv() (*RecordResponse, error)
    60  	grpc.ClientStream
    61  }
    62  
    63  type recorderRecordClient struct {
    64  	grpc.ClientStream
    65  }
    66  
    67  func (x *recorderRecordClient) Send(m *RecordRequest) error {
    68  	return x.ClientStream.SendMsg(m)
    69  }
    70  
    71  func (x *recorderRecordClient) Recv() (*RecordResponse, error) {
    72  	m := new(RecordResponse)
    73  	if err := x.ClientStream.RecvMsg(m); err != nil {
    74  		return nil, err
    75  	}
    76  	return m, nil
    77  }
    78  
    79  // RecorderServer is the server API for Recorder service.
    80  // All implementations should embed UnimplementedRecorderServer
    81  // for forward compatibility
    82  //
    83  // Recorder implements the Hubble module for capturing network packets
    84  type RecorderServer interface {
    85  	// Record can start and stop a single recording. The recording is
    86  	// automatically stopped if the client aborts this rpc call.
    87  	Record(Recorder_RecordServer) error
    88  }
    89  
    90  // UnimplementedRecorderServer should be embedded to have forward compatible implementations.
    91  type UnimplementedRecorderServer struct {
    92  }
    93  
    94  func (UnimplementedRecorderServer) Record(Recorder_RecordServer) error {
    95  	return status.Errorf(codes.Unimplemented, "method Record not implemented")
    96  }
    97  
    98  // UnsafeRecorderServer may be embedded to opt out of forward compatibility for this service.
    99  // Use of this interface is not recommended, as added methods to RecorderServer will
   100  // result in compilation errors.
   101  type UnsafeRecorderServer interface {
   102  	mustEmbedUnimplementedRecorderServer()
   103  }
   104  
   105  func RegisterRecorderServer(s grpc.ServiceRegistrar, srv RecorderServer) {
   106  	s.RegisterService(&Recorder_ServiceDesc, srv)
   107  }
   108  
   109  func _Recorder_Record_Handler(srv interface{}, stream grpc.ServerStream) error {
   110  	return srv.(RecorderServer).Record(&recorderRecordServer{ServerStream: stream})
   111  }
   112  
   113  type Recorder_RecordServer interface {
   114  	Send(*RecordResponse) error
   115  	Recv() (*RecordRequest, error)
   116  	grpc.ServerStream
   117  }
   118  
   119  type recorderRecordServer struct {
   120  	grpc.ServerStream
   121  }
   122  
   123  func (x *recorderRecordServer) Send(m *RecordResponse) error {
   124  	return x.ServerStream.SendMsg(m)
   125  }
   126  
   127  func (x *recorderRecordServer) Recv() (*RecordRequest, error) {
   128  	m := new(RecordRequest)
   129  	if err := x.ServerStream.RecvMsg(m); err != nil {
   130  		return nil, err
   131  	}
   132  	return m, nil
   133  }
   134  
   135  // Recorder_ServiceDesc is the grpc.ServiceDesc for Recorder service.
   136  // It's only intended for direct use with grpc.RegisterService,
   137  // and not to be introspected or modified (even as a copy)
   138  var Recorder_ServiceDesc = grpc.ServiceDesc{
   139  	ServiceName: "recorder.Recorder",
   140  	HandlerType: (*RecorderServer)(nil),
   141  	Methods:     []grpc.MethodDesc{},
   142  	Streams: []grpc.StreamDesc{
   143  		{
   144  			StreamName:    "Record",
   145  			Handler:       _Recorder_Record_Handler,
   146  			ServerStreams: true,
   147  			ClientStreams: true,
   148  		},
   149  	},
   150  	Metadata: "recorder/recorder.proto",
   151  }