// Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: // - protoc-gen-go-grpc v1.2.0 // - protoc v3.21.5 // source: agent/director.proto package agent 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 // DirectorClient is the client API for Director 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 DirectorClient interface { // Deprecated: Do not use. // Report a consistent Snapshot of information to the DCP. This // method is deprecated, you should call ReportStream instead. Report(ctx context.Context, in *Snapshot, opts ...grpc.CallOption) (*SnapshotResponse, error) // Report a consistent Snapshot of information to the DCP. ReportStream(ctx context.Context, opts ...grpc.CallOption) (Director_ReportStreamClient, error) // Report a consistent Diagnostics snapshot of information to the DCP. StreamDiagnostics(ctx context.Context, opts ...grpc.CallOption) (Director_StreamDiagnosticsClient, error) // Stream metrics to the DCP. StreamMetrics(ctx context.Context, opts ...grpc.CallOption) (Director_StreamMetricsClient, error) // Retrieve Directives from the DCP Retrieve(ctx context.Context, in *Identity, opts ...grpc.CallOption) (Director_RetrieveClient, error) // Reports the result of a command execution to the cloud ReportCommandResult(ctx context.Context, in *CommandResult, opts ...grpc.CallOption) (*CommandResultResponse, error) } type directorClient struct { cc grpc.ClientConnInterface } func NewDirectorClient(cc grpc.ClientConnInterface) DirectorClient { return &directorClient{cc} } // Deprecated: Do not use. func (c *directorClient) Report(ctx context.Context, in *Snapshot, opts ...grpc.CallOption) (*SnapshotResponse, error) { out := new(SnapshotResponse) err := c.cc.Invoke(ctx, "/agent.Director/Report", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *directorClient) ReportStream(ctx context.Context, opts ...grpc.CallOption) (Director_ReportStreamClient, error) { stream, err := c.cc.NewStream(ctx, &Director_ServiceDesc.Streams[0], "/agent.Director/ReportStream", opts...) if err != nil { return nil, err } x := &directorReportStreamClient{stream} return x, nil } type Director_ReportStreamClient interface { Send(*RawSnapshotChunk) error CloseAndRecv() (*SnapshotResponse, error) grpc.ClientStream } type directorReportStreamClient struct { grpc.ClientStream } func (x *directorReportStreamClient) Send(m *RawSnapshotChunk) error { return x.ClientStream.SendMsg(m) } func (x *directorReportStreamClient) CloseAndRecv() (*SnapshotResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(SnapshotResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *directorClient) StreamDiagnostics(ctx context.Context, opts ...grpc.CallOption) (Director_StreamDiagnosticsClient, error) { stream, err := c.cc.NewStream(ctx, &Director_ServiceDesc.Streams[1], "/agent.Director/StreamDiagnostics", opts...) if err != nil { return nil, err } x := &directorStreamDiagnosticsClient{stream} return x, nil } type Director_StreamDiagnosticsClient interface { Send(*RawDiagnosticsChunk) error CloseAndRecv() (*DiagnosticsResponse, error) grpc.ClientStream } type directorStreamDiagnosticsClient struct { grpc.ClientStream } func (x *directorStreamDiagnosticsClient) Send(m *RawDiagnosticsChunk) error { return x.ClientStream.SendMsg(m) } func (x *directorStreamDiagnosticsClient) CloseAndRecv() (*DiagnosticsResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(DiagnosticsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *directorClient) StreamMetrics(ctx context.Context, opts ...grpc.CallOption) (Director_StreamMetricsClient, error) { stream, err := c.cc.NewStream(ctx, &Director_ServiceDesc.Streams[2], "/agent.Director/StreamMetrics", opts...) if err != nil { return nil, err } x := &directorStreamMetricsClient{stream} return x, nil } type Director_StreamMetricsClient interface { Send(*StreamMetricsMessage) error CloseAndRecv() (*StreamMetricsResponse, error) grpc.ClientStream } type directorStreamMetricsClient struct { grpc.ClientStream } func (x *directorStreamMetricsClient) Send(m *StreamMetricsMessage) error { return x.ClientStream.SendMsg(m) } func (x *directorStreamMetricsClient) CloseAndRecv() (*StreamMetricsResponse, error) { if err := x.ClientStream.CloseSend(); err != nil { return nil, err } m := new(StreamMetricsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *directorClient) Retrieve(ctx context.Context, in *Identity, opts ...grpc.CallOption) (Director_RetrieveClient, error) { stream, err := c.cc.NewStream(ctx, &Director_ServiceDesc.Streams[3], "/agent.Director/Retrieve", opts...) if err != nil { return nil, err } x := &directorRetrieveClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } if err := x.ClientStream.CloseSend(); err != nil { return nil, err } return x, nil } type Director_RetrieveClient interface { Recv() (*Directive, error) grpc.ClientStream } type directorRetrieveClient struct { grpc.ClientStream } func (x *directorRetrieveClient) Recv() (*Directive, error) { m := new(Directive) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *directorClient) ReportCommandResult(ctx context.Context, in *CommandResult, opts ...grpc.CallOption) (*CommandResultResponse, error) { out := new(CommandResultResponse) err := c.cc.Invoke(ctx, "/agent.Director/ReportCommandResult", in, out, opts...) if err != nil { return nil, err } return out, nil } // DirectorServer is the server API for Director service. // All implementations must embed UnimplementedDirectorServer // for forward compatibility type DirectorServer interface { // Deprecated: Do not use. // Report a consistent Snapshot of information to the DCP. This // method is deprecated, you should call ReportStream instead. Report(context.Context, *Snapshot) (*SnapshotResponse, error) // Report a consistent Snapshot of information to the DCP. ReportStream(Director_ReportStreamServer) error // Report a consistent Diagnostics snapshot of information to the DCP. StreamDiagnostics(Director_StreamDiagnosticsServer) error // Stream metrics to the DCP. StreamMetrics(Director_StreamMetricsServer) error // Retrieve Directives from the DCP Retrieve(*Identity, Director_RetrieveServer) error // Reports the result of a command execution to the cloud ReportCommandResult(context.Context, *CommandResult) (*CommandResultResponse, error) mustEmbedUnimplementedDirectorServer() } // UnimplementedDirectorServer must be embedded to have forward compatible implementations. type UnimplementedDirectorServer struct { } func (UnimplementedDirectorServer) Report(context.Context, *Snapshot) (*SnapshotResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Report not implemented") } func (UnimplementedDirectorServer) ReportStream(Director_ReportStreamServer) error { return status.Errorf(codes.Unimplemented, "method ReportStream not implemented") } func (UnimplementedDirectorServer) StreamDiagnostics(Director_StreamDiagnosticsServer) error { return status.Errorf(codes.Unimplemented, "method StreamDiagnostics not implemented") } func (UnimplementedDirectorServer) StreamMetrics(Director_StreamMetricsServer) error { return status.Errorf(codes.Unimplemented, "method StreamMetrics not implemented") } func (UnimplementedDirectorServer) Retrieve(*Identity, Director_RetrieveServer) error { return status.Errorf(codes.Unimplemented, "method Retrieve not implemented") } func (UnimplementedDirectorServer) ReportCommandResult(context.Context, *CommandResult) (*CommandResultResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ReportCommandResult not implemented") } func (UnimplementedDirectorServer) mustEmbedUnimplementedDirectorServer() {} // UnsafeDirectorServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to DirectorServer will // result in compilation errors. type UnsafeDirectorServer interface { mustEmbedUnimplementedDirectorServer() } func RegisterDirectorServer(s grpc.ServiceRegistrar, srv DirectorServer) { s.RegisterService(&Director_ServiceDesc, srv) } func _Director_Report_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(Snapshot) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DirectorServer).Report(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/agent.Director/Report", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DirectorServer).Report(ctx, req.(*Snapshot)) } return interceptor(ctx, in, info, handler) } func _Director_ReportStream_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(DirectorServer).ReportStream(&directorReportStreamServer{stream}) } type Director_ReportStreamServer interface { SendAndClose(*SnapshotResponse) error Recv() (*RawSnapshotChunk, error) grpc.ServerStream } type directorReportStreamServer struct { grpc.ServerStream } func (x *directorReportStreamServer) SendAndClose(m *SnapshotResponse) error { return x.ServerStream.SendMsg(m) } func (x *directorReportStreamServer) Recv() (*RawSnapshotChunk, error) { m := new(RawSnapshotChunk) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Director_StreamDiagnostics_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(DirectorServer).StreamDiagnostics(&directorStreamDiagnosticsServer{stream}) } type Director_StreamDiagnosticsServer interface { SendAndClose(*DiagnosticsResponse) error Recv() (*RawDiagnosticsChunk, error) grpc.ServerStream } type directorStreamDiagnosticsServer struct { grpc.ServerStream } func (x *directorStreamDiagnosticsServer) SendAndClose(m *DiagnosticsResponse) error { return x.ServerStream.SendMsg(m) } func (x *directorStreamDiagnosticsServer) Recv() (*RawDiagnosticsChunk, error) { m := new(RawDiagnosticsChunk) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Director_StreamMetrics_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(DirectorServer).StreamMetrics(&directorStreamMetricsServer{stream}) } type Director_StreamMetricsServer interface { SendAndClose(*StreamMetricsResponse) error Recv() (*StreamMetricsMessage, error) grpc.ServerStream } type directorStreamMetricsServer struct { grpc.ServerStream } func (x *directorStreamMetricsServer) SendAndClose(m *StreamMetricsResponse) error { return x.ServerStream.SendMsg(m) } func (x *directorStreamMetricsServer) Recv() (*StreamMetricsMessage, error) { m := new(StreamMetricsMessage) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func _Director_Retrieve_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(Identity) if err := stream.RecvMsg(m); err != nil { return err } return srv.(DirectorServer).Retrieve(m, &directorRetrieveServer{stream}) } type Director_RetrieveServer interface { Send(*Directive) error grpc.ServerStream } type directorRetrieveServer struct { grpc.ServerStream } func (x *directorRetrieveServer) Send(m *Directive) error { return x.ServerStream.SendMsg(m) } func _Director_ReportCommandResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CommandResult) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(DirectorServer).ReportCommandResult(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/agent.Director/ReportCommandResult", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(DirectorServer).ReportCommandResult(ctx, req.(*CommandResult)) } return interceptor(ctx, in, info, handler) } // Director_ServiceDesc is the grpc.ServiceDesc for Director service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) var Director_ServiceDesc = grpc.ServiceDesc{ ServiceName: "agent.Director", HandlerType: (*DirectorServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "Report", Handler: _Director_Report_Handler, }, { MethodName: "ReportCommandResult", Handler: _Director_ReportCommandResult_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "ReportStream", Handler: _Director_ReportStream_Handler, ClientStreams: true, }, { StreamName: "StreamDiagnostics", Handler: _Director_StreamDiagnostics_Handler, ClientStreams: true, }, { StreamName: "StreamMetrics", Handler: _Director_StreamMetrics_Handler, ClientStreams: true, }, { StreamName: "Retrieve", Handler: _Director_Retrieve_Handler, ServerStreams: true, }, }, Metadata: "agent/director.proto", }