output

type Logger struct {
	// contains filtered or unexported fields
}

type Manager interface {

	// Verify checks the output's configuration without launching it
	Verify(model.Output) (model.ErrorMessage, error)

	// Load loads outputs from backend store and launches the ones that aren't
	// up and running yet. The Load call might be performed multiple times to
	// update the list. The field mask is the system-level field mask, ie forced
	// field mask
	Refresh([]model.Output, model.FieldMask)

	// Update refreshes the output. If it isn't launched yet it will be
	// launched. If it is already running the new configuration will be
	// applied. The field mask is the system field mask, ie the forced
	// field mask
	Update(model.Output, model.FieldMask) error

	// Stop stops a single output, typically if they have been deleted.
	Stop(model.OutputKey) error

	// Shutdown shuts down all of the running outputs.
	Shutdown()

	// Get returns the output. If the output isn't running or is unknown it
	// will return an error. The output includes the current logs.
	Get(model.OutputKey) (Output, error)

	// Publish publishes a data message to the running outputs. If there's no
	// outputs subscribing to the data it will be discarded.
	Publish(model.DataMessage)

	// Subscribe subscribes to a topic
	Subscribe(collectionID model.CollectionKey) <-chan interface{}

	// Unsubscribe unsubscribes from a topic
	Unsubscribe(ch <-chan interface{})
}

type Output interface {
	// Validate verifies the configuraton for the output. Error messages that
	// should be provided to the end user is returned as the 2nd parameter.
	// On success the error return value is nil.
	Validate(config model.OutputConfig) (model.ErrorMessage, error)
	// Start launches the output. This is non blocking, ie if the output
	// must connect to a remote server or perform some sort initialization it
	// will do so in a separate goroutine. The output will stop automatically
	// when the message channel is closed. If the message channel is closed
	// the output should attempt empty any remaining messages in the queue.
	Start(config model.OutputConfig, collectionFieldMask model.FieldMask, systemFieldMask model.FieldMask, message <-chan interface{})
	// Stop halts the output. Any buffered messages that can't be sent during
	// the timeout will be discarded by the output. When the Stop call returns
	// the output has stopped.
	Stop(timeout time.Duration)
	// Logs returns end user logs for the output.
	Logs() []model.OutputLogEntry
	// Status reports the internal status of the forwarder.
	Status() model.OutputStatus
}