github.com/v2fly/v2ray-core/v5@v5.16.2-0.20240507031116-8191faa6e095/app/log/command/config_grpc.pb.go (about)

     1  package command
     2  
     3  import (
     4  	context "context"
     5  	grpc "google.golang.org/grpc"
     6  	codes "google.golang.org/grpc/codes"
     7  	status "google.golang.org/grpc/status"
     8  )
     9  
    10  // This is a compile-time assertion to ensure that this generated file
    11  // is compatible with the grpc package it is being compiled against.
    12  // Requires gRPC-Go v1.32.0 or later.
    13  const _ = grpc.SupportPackageIsVersion7
    14  
    15  const (
    16  	LoggerService_RestartLogger_FullMethodName = "/v2ray.core.app.log.command.LoggerService/RestartLogger"
    17  	LoggerService_FollowLog_FullMethodName     = "/v2ray.core.app.log.command.LoggerService/FollowLog"
    18  )
    19  
    20  // LoggerServiceClient is the client API for LoggerService service.
    21  //
    22  // 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.
    23  type LoggerServiceClient interface {
    24  	RestartLogger(ctx context.Context, in *RestartLoggerRequest, opts ...grpc.CallOption) (*RestartLoggerResponse, error)
    25  	// Unstable interface
    26  	FollowLog(ctx context.Context, in *FollowLogRequest, opts ...grpc.CallOption) (LoggerService_FollowLogClient, error)
    27  }
    28  
    29  type loggerServiceClient struct {
    30  	cc grpc.ClientConnInterface
    31  }
    32  
    33  func NewLoggerServiceClient(cc grpc.ClientConnInterface) LoggerServiceClient {
    34  	return &loggerServiceClient{cc}
    35  }
    36  
    37  func (c *loggerServiceClient) RestartLogger(ctx context.Context, in *RestartLoggerRequest, opts ...grpc.CallOption) (*RestartLoggerResponse, error) {
    38  	out := new(RestartLoggerResponse)
    39  	err := c.cc.Invoke(ctx, LoggerService_RestartLogger_FullMethodName, in, out, opts...)
    40  	if err != nil {
    41  		return nil, err
    42  	}
    43  	return out, nil
    44  }
    45  
    46  func (c *loggerServiceClient) FollowLog(ctx context.Context, in *FollowLogRequest, opts ...grpc.CallOption) (LoggerService_FollowLogClient, error) {
    47  	stream, err := c.cc.NewStream(ctx, &LoggerService_ServiceDesc.Streams[0], LoggerService_FollowLog_FullMethodName, opts...)
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  	x := &loggerServiceFollowLogClient{stream}
    52  	if err := x.ClientStream.SendMsg(in); err != nil {
    53  		return nil, err
    54  	}
    55  	if err := x.ClientStream.CloseSend(); err != nil {
    56  		return nil, err
    57  	}
    58  	return x, nil
    59  }
    60  
    61  type LoggerService_FollowLogClient interface {
    62  	Recv() (*FollowLogResponse, error)
    63  	grpc.ClientStream
    64  }
    65  
    66  type loggerServiceFollowLogClient struct {
    67  	grpc.ClientStream
    68  }
    69  
    70  func (x *loggerServiceFollowLogClient) Recv() (*FollowLogResponse, error) {
    71  	m := new(FollowLogResponse)
    72  	if err := x.ClientStream.RecvMsg(m); err != nil {
    73  		return nil, err
    74  	}
    75  	return m, nil
    76  }
    77  
    78  // LoggerServiceServer is the server API for LoggerService service.
    79  // All implementations must embed UnimplementedLoggerServiceServer
    80  // for forward compatibility
    81  type LoggerServiceServer interface {
    82  	RestartLogger(context.Context, *RestartLoggerRequest) (*RestartLoggerResponse, error)
    83  	// Unstable interface
    84  	FollowLog(*FollowLogRequest, LoggerService_FollowLogServer) error
    85  	mustEmbedUnimplementedLoggerServiceServer()
    86  }
    87  
    88  // UnimplementedLoggerServiceServer must be embedded to have forward compatible implementations.
    89  type UnimplementedLoggerServiceServer struct {
    90  }
    91  
    92  func (UnimplementedLoggerServiceServer) RestartLogger(context.Context, *RestartLoggerRequest) (*RestartLoggerResponse, error) {
    93  	return nil, status.Errorf(codes.Unimplemented, "method RestartLogger not implemented")
    94  }
    95  func (UnimplementedLoggerServiceServer) FollowLog(*FollowLogRequest, LoggerService_FollowLogServer) error {
    96  	return status.Errorf(codes.Unimplemented, "method FollowLog not implemented")
    97  }
    98  func (UnimplementedLoggerServiceServer) mustEmbedUnimplementedLoggerServiceServer() {}
    99  
   100  // UnsafeLoggerServiceServer may be embedded to opt out of forward compatibility for this service.
   101  // Use of this interface is not recommended, as added methods to LoggerServiceServer will
   102  // result in compilation errors.
   103  type UnsafeLoggerServiceServer interface {
   104  	mustEmbedUnimplementedLoggerServiceServer()
   105  }
   106  
   107  func RegisterLoggerServiceServer(s grpc.ServiceRegistrar, srv LoggerServiceServer) {
   108  	s.RegisterService(&LoggerService_ServiceDesc, srv)
   109  }
   110  
   111  func _LoggerService_RestartLogger_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   112  	in := new(RestartLoggerRequest)
   113  	if err := dec(in); err != nil {
   114  		return nil, err
   115  	}
   116  	if interceptor == nil {
   117  		return srv.(LoggerServiceServer).RestartLogger(ctx, in)
   118  	}
   119  	info := &grpc.UnaryServerInfo{
   120  		Server:     srv,
   121  		FullMethod: LoggerService_RestartLogger_FullMethodName,
   122  	}
   123  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   124  		return srv.(LoggerServiceServer).RestartLogger(ctx, req.(*RestartLoggerRequest))
   125  	}
   126  	return interceptor(ctx, in, info, handler)
   127  }
   128  
   129  func _LoggerService_FollowLog_Handler(srv interface{}, stream grpc.ServerStream) error {
   130  	m := new(FollowLogRequest)
   131  	if err := stream.RecvMsg(m); err != nil {
   132  		return err
   133  	}
   134  	return srv.(LoggerServiceServer).FollowLog(m, &loggerServiceFollowLogServer{stream})
   135  }
   136  
   137  type LoggerService_FollowLogServer interface {
   138  	Send(*FollowLogResponse) error
   139  	grpc.ServerStream
   140  }
   141  
   142  type loggerServiceFollowLogServer struct {
   143  	grpc.ServerStream
   144  }
   145  
   146  func (x *loggerServiceFollowLogServer) Send(m *FollowLogResponse) error {
   147  	return x.ServerStream.SendMsg(m)
   148  }
   149  
   150  // LoggerService_ServiceDesc is the grpc.ServiceDesc for LoggerService service.
   151  // It's only intended for direct use with grpc.RegisterService,
   152  // and not to be introspected or modified (even as a copy)
   153  var LoggerService_ServiceDesc = grpc.ServiceDesc{
   154  	ServiceName: "v2ray.core.app.log.command.LoggerService",
   155  	HandlerType: (*LoggerServiceServer)(nil),
   156  	Methods: []grpc.MethodDesc{
   157  		{
   158  			MethodName: "RestartLogger",
   159  			Handler:    _LoggerService_RestartLogger_Handler,
   160  		},
   161  	},
   162  	Streams: []grpc.StreamDesc{
   163  		{
   164  			StreamName:    "FollowLog",
   165  			Handler:       _LoggerService_FollowLog_Handler,
   166  			ServerStreams: true,
   167  		},
   168  	},
   169  	Metadata: "app/log/command/config.proto",
   170  }