modules

type AlertParams ¶

type AlertParams struct {
	Message string `json:"message"`
}

AlertParams describes the parameters used in an alert message

type ConfigParams ¶

type ConfigParams struct {
	Config   interface{}       `json:"config"`
	Hostname string            `json:"hostname"`
	Env      interface{}       `json:"environment"`
	Tags     map[string]string `json:"tags"`
}

type HasEnhancedPrivacy ¶

type HasEnhancedPrivacy interface {
	EnhancePrivacy(Result) (Result, error)
}

type HasParamsCreator ¶

type HasParamsCreator interface {
	ParamsCreator() (interface{}, error)
}

HasParamsCreator implements a function that creates module parameters

type HasParamsParser ¶

type HasParamsParser interface {
	ParamsParser([]string) (interface{}, error)
}

HasParamsParser implements a function that parses command line parameters

type HasResultsPrinter ¶

type HasResultsPrinter interface {
	PrintResults(Result, bool) ([]string, error)
}

HasResultsPrinter implements functions used by module to print information

type LogParams ¶

type LogParams struct {
	Message string `json:"message"`
}

Parameter format expected for a log message

type Message ¶

type Message struct {
	Class       MessageClass `json:"class"`                 // represent the type of message being passed to the module
	Parameters  interface{}  `json:"parameters,omitempty"`  // for `parameters` class, this interface contains the module parameters
	PersistSock string       `json:"persistsock,omitempty"` // Persistent module socket path if required
}

Message defines the input messages received by modules.

All messages will have Class and Parameters set. PersistSock is used in a case where a parameters message is being sent for a persistent module. In this case, PersistSock will contain the socket specification the module has registered as listening on.

func ReadInput(r ModuleReader) (msg Message, err error)

type MessageClass ¶

type MessageClass string

const (
	MsgClassParameters MessageClass = "parameters"
	MsgClassStop       MessageClass = "stop"
	MsgClassPing       MessageClass = "ping"
	MsgClassLog        MessageClass = "log"
	MsgClassRegister   MessageClass = "register"
	MsgClassConfig     MessageClass = "config"
	MsgClassAlert      MessageClass = "alert"
)

type ModuleReader ¶

type ModuleReader struct {
	Reader       io.Reader
	BufferReader *bufio.Reader
}

ModuleReader is used to read module communications. It's intent is to wrap the initial reader (e.g., stdin) with a buffered reader that will exist for the lifetime of execution of the module. When the module reads input, it will read from BufferReader inside ModuleReader since our communication is line delimited, so we want to make sure we allocate this buffer only once.

func NewModuleReader(r io.Reader) (ret ModuleReader)

type ModuleWriter ¶

type ModuleWriter struct {
	Writer io.Writer
}

ModuleWriter is used to write module communications. We don't require bufio on writes, but this type exists just to provide consistency with ModuleReader.

func NewModuleWriter(w io.Writer) (ret ModuleWriter)

type Moduler ¶

type Moduler interface {
	NewRun() Runner
}

A mig module implements this interface

type PersistRunner ¶

type PersistRunner interface {
	RunPersist(ModuleReader, ModuleWriter)
	PersistModConfig() interface{}
}

PersistRunner provides the interface to execution of a persistent module. All modules will satisfy Runner. Persistent modules will satisfy both Runner and PersistRunner.

type RegParams ¶

type RegParams struct {
	SockPath string `json:"sockpath"`
}

Parameter format expected for a register message

type Result ¶

type Result struct {
	FoundAnything bool        `json:"foundanything"`
	Success       bool        `json:"success"`
	Elements      interface{} `json:"elements"`
	Statistics    interface{} `json:"statistics"`
	Errors        []string    `json:"errors"`
}

Result implement the base type for results returned by modules. All modules must return this type of result. The fields are:

• FoundAnything: a boolean that must be set to true if the module ran a search that returned at least one positive result

• Success: a boolean that must be set to true if the module ran without fatal errors. soft errors are reported in Errors

• Elements: an undefined type that can be customized by the module to contain the detailled results

• Statistics: an undefined type that can be customized by the module to contain some information about how it ran

• Errors: an array of strings that contain non-fatal errors encountered by the module

func (r Result) GetElements(el interface{}) (err error)

func (r Result) GetStatistics(stats interface{}) (err error)

type Runner ¶

type Runner interface {
	Run(ModuleReader) string
	ValidateParameters() error
}

Runner provides the interface to an execution of a module