// Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: // - protoc-gen-go-grpc v1.3.0 // - protoc v5.29.1 // source: envoy/service/tap/v3/tap.proto package tapv3 import ( context "context" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" ) // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. // Requires gRPC-Go v1.32.0 or later. const _ = grpc.SupportPackageIsVersion7 const ( TapSinkService_StreamTaps_FullMethodName = "/envoy.service.tap.v3.TapSinkService/StreamTaps" ) // TapSinkServiceClient is the client API for TapSinkService service. // // 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. type TapSinkServiceClient interface { // Envoy will connect and send StreamTapsRequest messages forever. It does not expect any // response to be sent as nothing would be done in the case of failure. The server should // disconnect if it expects Envoy to reconnect. StreamTaps(ctx context.Context, opts ...grpc.CallOption) (TapSinkService_StreamTapsClient, error) } type tapSinkServiceClient struct { cc grpc.ClientConnInterface } func NewTapSinkServiceClient(cc grpc.ClientConnInterface) TapSinkServiceClient { return &tapSinkServiceClient{cc} } func (c *tapSinkServiceClient) StreamTaps(ctx context.Context, opts ...grpc.CallOption) (TapSinkService_StreamTapsClient, error) { stream, err := c.cc.NewStream(ctx, &TapSinkService_ServiceDesc.Streams[0], TapSinkService_StreamTaps_FullMethodName, opts...) if err != nil { return nil, err } x := &tapSinkServiceStreamTapsClient{stream} return x, nil } type TapSinkService_StreamTapsClient interface { Send(*StreamTapsRequest) error CloseAndRecv() (*StreamTapsResponse, error) grpc.ClientStream } type tapSinkServiceStreamTapsClient struct { grpc.ClientStream } func (x *tapSinkServiceStreamTapsClient) Send(m *StreamTapsRequest) error { return x.ClientStream.SendMsg(m) } func (x *tapSinkServiceStreamTapsClient) CloseAndRecv() (*StreamTapsResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(StreamTapsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // TapSinkServiceServer is the server API for TapSinkService service. // All implementations should embed UnimplementedTapSinkServiceServer // for forward compatibility type TapSinkServiceServer interface { // Envoy will connect and send StreamTapsRequest messages forever. It does not expect any // response to be sent as nothing would be done in the case of failure. The server should // disconnect if it expects Envoy to reconnect. StreamTaps(TapSinkService_StreamTapsServer) error } // UnimplementedTapSinkServiceServer should be embedded to have forward compatible implementations. type UnimplementedTapSinkServiceServer struct { } func (UnimplementedTapSinkServiceServer) StreamTaps(TapSinkService_StreamTapsServer) error { return status.Errorf(codes.Unimplemented, "method StreamTaps not implemented") } // UnsafeTapSinkServiceServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to TapSinkServiceServer will // result in compilation errors. type UnsafeTapSinkServiceServer interface { mustEmbedUnimplementedTapSinkServiceServer() } func RegisterTapSinkServiceServer(s grpc.ServiceRegistrar, srv TapSinkServiceServer) { s.RegisterService(&TapSinkService_ServiceDesc, srv) } func _TapSinkService_StreamTaps_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(TapSinkServiceServer).StreamTaps(&tapSinkServiceStreamTapsServer{stream}) } type TapSinkService_StreamTapsServer interface { SendAndClose(*StreamTapsResponse) error Recv() (*StreamTapsRequest, error) grpc.ServerStream } type tapSinkServiceStreamTapsServer struct { grpc.ServerStream } func (x *tapSinkServiceStreamTapsServer) SendAndClose(m *StreamTapsResponse) error { return x.ServerStream.SendMsg(m) } func (x *tapSinkServiceStreamTapsServer) Recv() (*StreamTapsRequest, error) { m := new(StreamTapsRequest) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // TapSinkService_ServiceDesc is the grpc.ServiceDesc for TapSinkService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) var TapSinkService_ServiceDesc = grpc.ServiceDesc{ ServiceName: "envoy.service.tap.v3.TapSinkService", HandlerType: (*TapSinkServiceServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "StreamTaps", Handler: _TapSinkService_StreamTaps_Handler, ClientStreams: true, }, }, Metadata: "envoy/service/tap/v3/tap.proto", }