v.io: v.io/v23/services/logreader Index | Files

package logreader

import "v.io/v23/services/logreader"

Package logreader defines interfaces for reading log files remotely. nolint:golint

Index

Package Files

logreader.vdl.go

Constants

const AllEntries = int32(-1)

A special NumEntries value that indicates that all entries should be returned by ReadLog.

Variables

var LogFileDesc rpc.InterfaceDesc = descLogFile

LogFileDesc describes the LogFile interface.

type LogEntry Uses

type LogEntry struct {
    // The offset (in bytes) where this entry starts.
    Position int64
    // The content of the log entry.
    Line string
}

LogEntry is a log entry from a log file.

func (LogEntry) VDLIsZero Uses

func (x LogEntry) VDLIsZero() bool

func (*LogEntry) VDLRead Uses

func (x *LogEntry) VDLRead(dec vdl.Decoder) error

func (LogEntry) VDLReflect Uses

func (LogEntry) VDLReflect(struct {
    Name string `vdl:"v.io/v23/services/logreader.LogEntry"`
})

func (LogEntry) VDLWrite Uses

func (x LogEntry) VDLWrite(enc vdl.Encoder) error

type LogFileClientMethods Uses

type LogFileClientMethods interface {
    // Size returns the number of bytes in the receiving object.
    Size(*context.T, ...rpc.CallOpt) (int64, error)
    // ReadLog receives up to numEntries log entries starting at the
    // startPos offset (in bytes) in the receiving object. Each stream chunk
    // contains one log entry.
    //
    // If follow is true, ReadLog will block and wait for more entries to
    // arrive when it reaches the end of the file.
    //
    // ReadLog returns the position where it stopped reading, i.e. the
    // position where the next entry starts. This value can be used as
    // startPos for successive calls to ReadLog.
    //
    // The returned error will be EndOfFile if and only if ReadLog reached the
    // end of the file and no log entries were returned.
    ReadLog(_ *context.T, startPos int64, numEntries int32, follow bool, _ ...rpc.CallOpt) (LogFileReadLogClientCall, error)
}

LogFileClientMethods is the client interface containing LogFile methods.

LogFile can be used to access log files remotely.

type LogFileClientStub Uses

type LogFileClientStub interface {
    LogFileClientMethods
}

LogFileClientStub embeds LogFileClientMethods and is a placeholder for additional management operations.

func LogFileClient Uses

func LogFileClient(name string) LogFileClientStub

LogFileClient returns a client stub for LogFile.

type LogFileReadLogClientCall Uses

type LogFileReadLogClientCall interface {
    LogFileReadLogClientStream
    // Finish blocks until the server is done, and returns the positional return
    // values for call.
    //
    // Finish returns immediately if the call has been canceled; depending on the
    // timing the output could either be an error signaling cancelation, or the
    // valid positional return values from the server.
    //
    // Calling Finish is mandatory for releasing stream resources, unless the call
    // has been canceled or any of the other methods return an error.  Finish should
    // be called at most once.
    Finish() (int64, error)
}

LogFileReadLogClientCall represents the call returned from LogFile.ReadLog.

type LogFileReadLogClientStream Uses

type LogFileReadLogClientStream interface {
    // RecvStream returns the receiver side of the LogFile.ReadLog client stream.
    RecvStream() interface {
        // Advance stages an item so that it may be retrieved via Value.  Returns
        // true iff there is an item to retrieve.  Advance must be called before
        // Value is called.  May block if an item is not available.
        Advance() bool
        // Value returns the item that was staged by Advance.  May panic if Advance
        // returned false or was not called.  Never blocks.
        Value() LogEntry
        // Err returns any error encountered by Advance.  Never blocks.
        Err() error
    }
}

LogFileReadLogClientStream is the client stream for LogFile.ReadLog.

type LogFileReadLogServerCall Uses

type LogFileReadLogServerCall interface {
    rpc.ServerCall
    LogFileReadLogServerStream
}

LogFileReadLogServerCall represents the context passed to LogFile.ReadLog.

type LogFileReadLogServerCallStub Uses

type LogFileReadLogServerCallStub struct {
    rpc.StreamServerCall
}

LogFileReadLogServerCallStub is a wrapper that converts rpc.StreamServerCall into a typesafe stub that implements LogFileReadLogServerCall.

func (*LogFileReadLogServerCallStub) Init Uses

func (s *LogFileReadLogServerCallStub) Init(call rpc.StreamServerCall)

Init initializes LogFileReadLogServerCallStub from rpc.StreamServerCall.

func (*LogFileReadLogServerCallStub) SendStream Uses

func (s *LogFileReadLogServerCallStub) SendStream() interface {
    Send(item LogEntry) error
}

SendStream returns the send side of the LogFile.ReadLog server stream.

type LogFileReadLogServerStream Uses

type LogFileReadLogServerStream interface {
    // SendStream returns the send side of the LogFile.ReadLog server stream.
    SendStream() interface {
        // Send places the item onto the output stream.  Returns errors encountered
        // while sending.  Blocks if there is no buffer space; will unblock when
        // buffer space is available.
        Send(item LogEntry) error
    }
}

LogFileReadLogServerStream is the server stream for LogFile.ReadLog.

type LogFileServerMethods Uses

type LogFileServerMethods interface {
    // Size returns the number of bytes in the receiving object.
    Size(*context.T, rpc.ServerCall) (int64, error)
    // ReadLog receives up to numEntries log entries starting at the
    // startPos offset (in bytes) in the receiving object. Each stream chunk
    // contains one log entry.
    //
    // If follow is true, ReadLog will block and wait for more entries to
    // arrive when it reaches the end of the file.
    //
    // ReadLog returns the position where it stopped reading, i.e. the
    // position where the next entry starts. This value can be used as
    // startPos for successive calls to ReadLog.
    //
    // The returned error will be EndOfFile if and only if ReadLog reached the
    // end of the file and no log entries were returned.
    ReadLog(_ *context.T, _ LogFileReadLogServerCall, startPos int64, numEntries int32, follow bool) (int64, error)
}

LogFileServerMethods is the interface a server writer implements for LogFile.

LogFile can be used to access log files remotely.

type LogFileServerStub Uses

type LogFileServerStub interface {
    LogFileServerStubMethods
    // DescribeInterfaces the LogFile interfaces.
    Describe__() []rpc.InterfaceDesc
}

LogFileServerStub adds universal methods to LogFileServerStubMethods.

func LogFileServer Uses

func LogFileServer(impl LogFileServerMethods) LogFileServerStub

LogFileServer returns a server stub for LogFile. It converts an implementation of LogFileServerMethods into an object that may be used by rpc.Server.

type LogFileServerStubMethods Uses

type LogFileServerStubMethods interface {
    // Size returns the number of bytes in the receiving object.
    Size(*context.T, rpc.ServerCall) (int64, error)
    // ReadLog receives up to numEntries log entries starting at the
    // startPos offset (in bytes) in the receiving object. Each stream chunk
    // contains one log entry.
    //
    // If follow is true, ReadLog will block and wait for more entries to
    // arrive when it reaches the end of the file.
    //
    // ReadLog returns the position where it stopped reading, i.e. the
    // position where the next entry starts. This value can be used as
    // startPos for successive calls to ReadLog.
    //
    // The returned error will be EndOfFile if and only if ReadLog reached the
    // end of the file and no log entries were returned.
    ReadLog(_ *context.T, _ *LogFileReadLogServerCallStub, startPos int64, numEntries int32, follow bool) (int64, error)
}

LogFileServerStubMethods is the server interface containing LogFile methods, as expected by rpc.Server. The only difference between this interface and LogFileServerMethods is the streaming methods.

Package logreader imports 6 packages (graph) and is imported by 8 packages. Updated 2020-10-25. Refresh now. Tools for package owners.