protocol

package
v0.0.0-...-b4573b1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 23, 2024 License: MIT Imports: 14 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	MsgTypeHelo = "HELO"
	MsgTypePing = "PING"
	MsgTypePong = "PONG"
)
View Source 
const (
	OptSize       string = "size"
	OptChunk      string = "chunk"
	OptCompressed string = "compressed"
	OptValGZIP    string = "gzip"
)

Variables

This section is empty.

Functions

func GetChunk 

func GetChunk(b []byte) (string, error)

GetChunk searches a marshaled message for the "chunk" option value and returns it. The chunk can be used for ack checks without the overhead of unmarshalling. GetChunk returns an error if no value is found.

func ValidatePingDigest 

func ValidatePingDigest(p *Ping, key, nonce []byte) error

ValidatePingDigest validates that the digest contained in the PING message is valid for the client hostname (as contained in the PING). Returns a non-nil error if validation fails, nil otherwise.

func ValidatePongDigest 

func ValidatePongDigest(p *Pong, key, nonce, salt []byte) error

ValidatePongDigest validates that the digest contained in the PONG message is valid for the server hostname (as contained in the PONG). Returns a non-nil error if validation fails, nil otherwise.

Types

type AckMessage 

type AckMessage struct {
	Ack string `msg:"ack"`
}

func (*AckMessage) DecodeMsg 

func (z *AckMessage) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (AckMessage) EncodeMsg 

func (z AckMessage) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (AckMessage) MarshalMsg 

func (z AckMessage) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (AckMessage) Msgsize 

func (z AckMessage) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*AckMessage) UnmarshalMsg 

func (z *AckMessage) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ChunkEncoder 

type ChunkEncoder interface {
	Chunk() (string, error)
	EncodeMsg(*msgp.Writer) error
}

ChunkEncoder wraps methods to encode a message and generate "chunk" IDs for use with Fluent's chunk-ack protocol. See https://github.com/fluent/fluentd/wiki/Forward-Protocol-Specification-v1#response for more information.

type ChunkReader 

type ChunkReader struct {
	R *msgp.Reader
	// contains filtered or unexported fields
}

func (*ChunkReader) Reset 

func (cr *ChunkReader) Reset(b []byte)

type Entry 

type Entry struct {
	// Timestamp can contain the timestamp in either seconds or nanoseconds
	Timestamp int64
	// Record is the actual event record.
	Record interface{}
}

EntryExt is the basic representation of an individual event. The timestamp is an int64 representing seconds since the epoch (UTC). The initial creator of the entry is responsible for converting to UTC.

func (*Entry) DecodeMsg 

func (z *Entry) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Entry) EncodeMsg 

func (z Entry) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (Entry) MarshalMsg 

func (z Entry) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Entry) Msgsize 

func (z Entry) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Entry) UnmarshalMsg 

func (z *Entry) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type EntryExt 

type EntryExt struct {
	// Timestamp can contain the timestamp in either seconds or nanoseconds
	Timestamp EventTime `msg:"eventTime,extension"`
	// Record is the actual event record. The object must be a map or
	// struct. Objects that implement the msgp.Encodable interface will
	// be the most performant.
	Record interface{}
}

EntryExt is the basic representation of an individual event, but using the msgpack extension format for the timestamp.

func (*EntryExt) DecodeMsg 

func (z *EntryExt) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (EntryExt) EncodeMsg 

func (z EntryExt) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (EntryExt) MarshalMsg 

func (z EntryExt) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (EntryExt) Msgsize 

func (z EntryExt) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*EntryExt) UnmarshalMsg 

func (z *EntryExt) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type EntryList 

type EntryList []EntryExt

func (*EntryList) DecodeMsg 

func (z *EntryList) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (EntryList) EncodeMsg 

func (z EntryList) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (EntryList) Equal 

func (el EntryList) Equal(e2 EntryList) bool

Equal compares two EntryList objects and returns true if they have exactly the same elements, false otherwise.

func (EntryList) MarshalMsg 

func (z EntryList) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (EntryList) MarshalPacked 

func (el EntryList) MarshalPacked() ([]byte, error)

func (EntryList) Msgsize 

func (z EntryList) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*EntryList) UnmarshalMsg 

func (z *EntryList) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

func (*EntryList) UnmarshalPacked 

func (el *EntryList) UnmarshalPacked(bits []byte) ([]byte, error)

type EventTime 

type EventTime struct {
	time.Time
}

EventTime is the fluent-forward representation of a timestamp

func EventTimeNow 

func EventTimeNow() EventTime

EventTimeNow returns an EventTime set to time.Now().UTC().

func (*EventTime) DecodeMsg 

func (z *EventTime) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (EventTime) EncodeMsg 

func (z EventTime) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*EventTime) ExtensionType 

func (et *EventTime) ExtensionType() int8

func (*EventTime) Len 

func (et *EventTime) Len() int

func (*EventTime) MarshalBinaryTo 

func (et *EventTime) MarshalBinaryTo(b []byte) error

MarshalBinaryTo implements the Extension interface for marshaling an EventTime into a byte slice.

func (EventTime) MarshalMsg 

func (z EventTime) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (EventTime) Msgsize 

func (z EventTime) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*EventTime) UnmarshalBinary 

func (et *EventTime) UnmarshalBinary(timeBytes []byte) error

UnmarshalBinary implements the Extension interface for unmarshaling into an EventTime object.

func (*EventTime) UnmarshalMsg 

func (z *EventTime) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ForwardMessage 

type ForwardMessage struct {
	// Tag is a dot-delimted string used to categorize events
	Tag string
	// Entries is the set of event objects to be carried in this message
	Entries EntryList
	// Options - used to control server behavior.  Same as above, may need to
	// switch to interface{} or similar at some point.
	Options *MessageOptions
}

ForwardMessage is used in Forward mode to send multiple events in a single msgpack array within a single request.

func NewForwardMessage 

func NewForwardMessage(
	tag string,
	entries EntryList,
) *ForwardMessage

NewForwardMessage creates a ForwardMessage from the supplied tag, EntryList, and MessageOptions. this function will set Options.Size to the length of the entry list.

func (*ForwardMessage) Chunk 

func (fm *ForwardMessage) Chunk() (string, error)

func (*ForwardMessage) DecodeMsg 

func (fm *ForwardMessage) DecodeMsg(dc *msgp.Reader) error

func (*ForwardMessage) EncodeMsg 

func (fm *ForwardMessage) EncodeMsg(dc *msgp.Writer) error

func (*ForwardMessage) MarshalMsg 

func (fm *ForwardMessage) MarshalMsg(bits []byte) ([]byte, error)

func (*ForwardMessage) Msgsize 

func (fm *ForwardMessage) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ForwardMessage) UnmarshalMsg 

func (fm *ForwardMessage) UnmarshalMsg(bits []byte) ([]byte, error)

type GzipCompressor 

type GzipCompressor struct {
	Buffer     *bytes.Buffer
	GzipWriter *gzip.Writer
}

func (*GzipCompressor) Bytes 

func (mc *GzipCompressor) Bytes() []byte

Bytes returns the gzip-compressed byte stream.

func (*GzipCompressor) Reset 

func (mc *GzipCompressor) Reset()

Reset resets the buffer to be empty, but it retains the underlying storage for use by future writes.

func (*GzipCompressor) Write 

func (mc *GzipCompressor) Write(bits []byte) error

Write writes to the compression stream.

type Helo 

type Helo struct {
	MessageType string
	Options     *HeloOpts
}

Helo is the initial handshake message, sent by the server and received by the client. Client will respond with a Ping.

func NewHelo 

func NewHelo(opts *HeloOpts) *Helo

NewHelo returns a Helo message with the specified options. if opts is nil, then a nonce is generated, auth is left empty, and keepalive is true.

func (*Helo) DecodeMsg 

func (z *Helo) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Helo) EncodeMsg 

func (z *Helo) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Helo) MarshalMsg 

func (z *Helo) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Helo) Msgsize 

func (z *Helo) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Helo) UnmarshalMsg 

func (z *Helo) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type HeloOpts 

type HeloOpts struct {
	Nonce     []byte `msg:"nonce"`
	Auth      []byte `msg:"auth"`
	Keepalive bool   `msg:"keepalive"`
}

func (*HeloOpts) DecodeMsg 

func (z *HeloOpts) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*HeloOpts) EncodeMsg 

func (z *HeloOpts) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*HeloOpts) MarshalMsg 

func (z *HeloOpts) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*HeloOpts) Msgsize 

func (z *HeloOpts) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*HeloOpts) UnmarshalMsg 

func (z *HeloOpts) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Message 

type Message struct {
	// Tag is a dot-delimited string used to categorize events
	Tag       string
	Timestamp int64
	Record    interface{}
	// Options - used to control server behavior.
	Options *MessageOptions
}

Message is used to send a single event at a time

func NewMessage 

func NewMessage(
	tag string,
	record interface{},
) *Message

NewMessage creates a Message from the supplied tag and record. The record object must be a map or struct. Objects that implement the msgp.Encodable interface will be the most performant. Timestamp is set to time.Now().UTC() and marshaled with second precision.

func (*Message) Chunk 

func (msg *Message) Chunk() (string, error)

func (*Message) DecodeMsg 

func (msg *Message) DecodeMsg(dc *msgp.Reader) error

func (*Message) EncodeMsg 

func (z *Message) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Message) MarshalMsg 

func (z *Message) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Message) Msgsize 

func (msg *Message) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Message) UnmarshalMsg 

func (msg *Message) UnmarshalMsg(bits []byte) ([]byte, error)

type MessageExt 

type MessageExt struct {
	Tag       string
	Timestamp EventTime `msg:"eventTime,extension"`
	Record    interface{}
	Options   *MessageOptions
}

MessageExt

func NewMessageExt 

func NewMessageExt(
	tag string,
	record interface{},
) *MessageExt

NewMessageExt creates a MessageExt from the supplied tag and record. The record object must be a map or struct. Objects that implement the msgp.Encodable interface will be the most performant. Timestamp is set to time.Now().UTC() and marshaled with subsecond precision.

func (*MessageExt) Chunk 

func (msg *MessageExt) Chunk() (string, error)

func (*MessageExt) DecodeMsg 

func (msg *MessageExt) DecodeMsg(dc *msgp.Reader) error

func (*MessageExt) EncodeMsg 

func (z *MessageExt) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageExt) MarshalMsg 

func (z *MessageExt) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageExt) Msgsize 

func (msg *MessageExt) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageExt) UnmarshalMsg 

func (msg *MessageExt) UnmarshalMsg(bits []byte) ([]byte, error)

type MessageOptions 

type MessageOptions struct {
	Size       *int   `msg:"size,omitempty"`
	Chunk      string `msg:"chunk,omitempty"`
	Compressed string `msg:"compressed,omitempty"`
}

func (*MessageOptions) DecodeMsg 

func (z *MessageOptions) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageOptions) EncodeMsg 

func (z *MessageOptions) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageOptions) MarshalMsg 

func (z *MessageOptions) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageOptions) Msgsize 

func (z *MessageOptions) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageOptions) UnmarshalMsg 

func (z *MessageOptions) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type PackedForwardMessage 

type PackedForwardMessage struct {
	// Tag is a dot-delimited string used to categorize events
	Tag string
	// EventStream is the set of events (entries in Fluent-speak) serialized
	// into a msgpack byte stream
	EventStream []byte
	// Options - used to control server behavior.  Same as above, may need to
	// switch to interface{} or similar at some point.
	Options *MessageOptions
}

PackedForwardMessage is just like ForwardMessage, except that the events are carried as a msgpack binary stream

func NewCompressedPackedForwardMessage 

func NewCompressedPackedForwardMessage(
	tag string, entries []EntryExt,
) (*PackedForwardMessage, error)

NewCompressedPackedForwardMessage returns a PackedForwardMessage with a gzip-compressed byte stream.

func NewCompressedPackedForwardMessageFromBytes 

func NewCompressedPackedForwardMessageFromBytes(
	tag string, entries []byte,
) (*PackedForwardMessage, error)

NewCompressedPackedForwardMessageFromBytes returns a PackedForwardMessage with a gzip-compressed byte stream.

func NewPackedForwardMessage 

func NewPackedForwardMessage(
	tag string,
	entries EntryList,
) (*PackedForwardMessage, error)

NewPackedForwardMessage creates a PackedForwardMessage from the supplied tag, EntryList, and MessageOptions. Regardless of the options supplied, this function will set Options.Size to the length of the entry list.

func NewPackedForwardMessageFromBytes 

func NewPackedForwardMessageFromBytes(
	tag string,
	entries []byte,
) *PackedForwardMessage

NewPackedForwardMessageFromBytes creates a PackedForwardMessage from the supplied tag, bytes, and MessageOptions. This function does not set Options.Size to the length of the entry list.

func (*PackedForwardMessage) Chunk 

func (msg *PackedForwardMessage) Chunk() (string, error)

func (*PackedForwardMessage) DecodeMsg 

func (msg *PackedForwardMessage) DecodeMsg(dc *msgp.Reader) error

func (*PackedForwardMessage) EncodeMsg 

func (z *PackedForwardMessage) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*PackedForwardMessage) MarshalMsg 

func (z *PackedForwardMessage) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*PackedForwardMessage) Msgsize 

func (msg *PackedForwardMessage) Msgsize() (s int)

func (*PackedForwardMessage) UnmarshalMsg 

func (msg *PackedForwardMessage) UnmarshalMsg(bits []byte) ([]byte, error)

type Ping 

type Ping struct {
	MessageType        string
	ClientHostname     string
	SharedKeySalt      []byte
	SharedKeyHexDigest string
	Username           string
	Password           string
}

Ping is the response message sent by the client after receiving a Helo from the server. Server will respond with a Pong.

func NewPing 

func NewPing(hostname string, sharedKey, salt, nonce []byte) (*Ping, error)

NewPing returns a PING message. The digest is computed from the hostname, key, salt, and nonce using SHA512.

func NewPingWithAuth 

func NewPingWithAuth(hostname string, sharedKey, salt, nonce []byte, username, password string) (*Ping, error)

NewPingWithAuth returns a PING message containing the username and password to be used for authentication. The digest is computed from the hostname, key, salt, and nonce using SHA512.

func (*Ping) DecodeMsg 

func (z *Ping) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Ping) EncodeMsg 

func (z *Ping) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Ping) MarshalMsg 

func (z *Ping) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Ping) Msgsize 

func (z *Ping) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Ping) UnmarshalMsg 

func (z *Ping) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Pong 

type Pong struct {
	MessageType        string
	AuthResult         bool
	Reason             string
	ServerHostname     string
	SharedKeyHexDigest string
}

Pong is the response message sent by the server after receiving a Ping from the client. A Pong concludes the handshake.

func NewPong 

func NewPong(authResult bool, reason string, hostname string, sharedKey []byte,
	helo *Helo, ping *Ping) (*Pong, error)

NewPong returns a PONG message. AuthResult indicates whether the credentials presented by the client were accepted and therefore whether the client can continue using the connection, switching from handshake mode to sending events. As with the PING, the digest is computed from the hostname, key, salt, and nonce using SHA512. Server implementations must use the nonce created for the initial Helo and the salt sent by the client in the Ping.

func (*Pong) DecodeMsg 

func (z *Pong) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Pong) EncodeMsg 

func (z *Pong) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Pong) MarshalMsg 

func (z *Pong) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Pong) Msgsize 

func (z *Pong) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Pong) UnmarshalMsg 

func (z *Pong) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawMessage 

type RawMessage []byte

RawMessage is a ChunkEncoder wrapper for []byte.

func (RawMessage) Chunk 

func (rm RawMessage) Chunk() (string, error)

Chunk searches the message for the chunk ID. In the case of RawMessage, Chunk is read-only. It returns an error if the chunk is not found.

func (*RawMessage) DecodeMsg 

func (z *RawMessage) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (RawMessage) EncodeMsg 

func (rm RawMessage) EncodeMsg(w *msgp.Writer) error

func (RawMessage) MarshalMsg 

func (z RawMessage) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (RawMessage) Msgsize 

func (z RawMessage) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*RawMessage) UnmarshalMsg 

func (z *RawMessage) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.