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 }