modules

Documentation

Overview

This package implements interfaces to write modules for MIG.

For a guide on how to write modules, head over to http://mig.mozilla.org/doc/modules.rst.html

Index

• Variables
• func MakeMessage(class MessageClass, params interface{}, comp bool) (rawMsg []byte, err error)
• func ReadInputParameters(r io.Reader, p interface{}) (err error)
• func Register(name string, mod Moduler)
• func WatchForStop(r io.Reader, stopChan *chan bool) error
• type HasParamsCreator
• type HasParamsParser
• type HasResultsPrinter
• type Message
  • func ReadInput(r io.Reader) (msg Message, err error)
• type MessageClass
• type Moduler
• type Result
  • func (r Result) GetElements(el interface{}) (err error)
  • func (r Result) GetStatistics(stats interface{}) (err error)
• type Runner

Variables

var Available = make(map[string]Moduler)

The set of registered modules

Functions

func MakeMessage

func MakeMessage(class MessageClass, params interface{}, comp bool) (rawMsg []byte, err error)

MakeMessage creates a new modules.Message with a given class and parameters and return the byte slice of the json marshalled message

func ReadInputParameters

func ReadInputParameters(r io.Reader, p interface{}) (err error)

ReadInputParameters reads the first line from stdin and expects to find a modules.Message of class `parameters`. This function uses ReadInput and will block waiting for data on stdin

func Register

func Register(name string, mod Moduler)

Register a new module as available

func WatchForStop

func WatchForStop(r io.Reader, stopChan *chan bool) error

WatchForStop continuously reads stdin for a stop message. When one is received, `true` is sent into the stop channel.

Types

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 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
}

Message defines the input messages received by modules.

func ReadInput

func ReadInput(r io.Reader) (msg Message, err error)

ReadInput reads one line of input from stdin, unmarshal it into a modules.Message and returns the message to the caller

type MessageClass

type MessageClass string

const (
	MsgClassParameters MessageClass = "parameters"
	MsgClassStop       MessageClass = "stop"
)

type Moduler

type Moduler interface {
	NewRun() Runner
}

A mig module implements this interface

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 (Result) GetElements

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

GetElements reads the elements from a struct of results into the el interface

func (Result) GetStatistics

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

GetStatistics reads the statistics from a struct of results into the stats interface

type Runner

type Runner interface {
	Run(io.Reader) string
	ValidateParameters() error
}

Runner provides the interface to an execution of a module