trigger

Documentation

Index

• func Factories() map[string]Factory
• func GetLogger(ref string) log.Logger
• func LegacyRegister(ref string, f Factory) error
• func NewHandlerContext(parentCtx context.Context, config *HandlerConfig) context.Context
• func Register(trigger Trigger, f Factory) error
• type ActionConfig
• type Callback
• type Config
  • func (c *Config) FixUp(md *Metadata) error
• type Descriptor
• type Factory
  • func GetFactory(ref string) Factory
• type Handler
  • func NewHandler(config *HandlerConfig, acts []action.Action, mf mapper.Factory, ...) (Handler, error)
• type HandlerConfig
  • func (hc *HandlerConfig) UnmarshalJSON(d []byte) error
• type HandlerInfo
  • func HandlerFromContext(ctx context.Context) (*HandlerInfo, bool)
• type InitContext
• type Metadata
  • func NewMetadata(mdStructs ...interface{}) *Metadata
• type SchemaConfig
• type Trigger

Functions

func Factories

func Factories() map[string]Factory

func GetLogger

func GetLogger(ref string) log.Logger

func LegacyRegister

func LegacyRegister(ref string, f Factory) error

DEPRECATED

func NewHandlerContext

func NewHandlerContext(parentCtx context.Context, config *HandlerConfig) context.Context

NewHandlerContext add the handler info to a new child context

func Register

func Register(trigger Trigger, f Factory) error

Types

type ActionConfig

type ActionConfig struct {
	*action.Config
	If     string                 `json:"if,omitempty"`
	Input  map[string]interface{} `json:"input,omitempty"`
	Output map[string]interface{} `json:"output,omitempty"`

	Act action.Action `json:"-,omitempty"`
}

ActionConfig is the configuration for the Action

type Callback

type Callback func(map[string]interface{})

type Config

type Config struct {
	Id       string                 `json:"id"`
	Ref      string                 `json:"ref"`
	Settings map[string]interface{} `json:"settings"`
	Handlers []*HandlerConfig       `json:"handlers"`

	//DEPRECATED
	Type string `json:"type,omitempty"`
	//todo add emiter mapper
	Event map[string]interface{} `json:"event"`
}

Config is the configuration for a Trigger

func (*Config) FixUp

func (c *Config) FixUp(md *Metadata) error

type Descriptor

type Descriptor struct {
	ID      string `json:"ref"`
	Version string `json:"version"`
}

type Factory

type Factory interface {

	// Metadata returns the metadata of the trigger
	Metadata() *Metadata

	// New create a new Trigger
	New(config *Config) (Trigger, error)
}

Factory is used to create new instances of a trigger

func GetFactory

func GetFactory(ref string) Factory

type Handler

type Handler interface {
	Name() string
	Settings() map[string]interface{}
	Handle(ctx context.Context, triggerData interface{}) (map[string]interface{}, error)
}

func NewHandler

func NewHandler(config *HandlerConfig, acts []action.Action, mf mapper.Factory, ef expression.Factory, runner action.Runner) (Handler, error)

type HandlerConfig

type HandlerConfig struct {
	Name     string                 `json:"name,omitempty"`
	Settings map[string]interface{} `json:"settings"`
	Actions  []*ActionConfig        `json:"actions"`
	Schemas  *SchemaConfig          `json:"schemas,omitempty"`
	// contains filtered or unexported fields
}

func (*HandlerConfig) UnmarshalJSON

func (hc *HandlerConfig) UnmarshalJSON(d []byte) error

UnmarshalJSON overrides the default UnmarshalJSON for TaskInst

type HandlerInfo

type HandlerInfo struct {
	Name string
}

func HandlerFromContext

func HandlerFromContext(ctx context.Context) (*HandlerInfo, bool)

HandlerFromContext returns the handler info stored in the context, if any.

type InitContext

type InitContext interface {

	// Logger the logger for the trigger
	Logger() log.Logger

	// GetHandlers gets the handlers associated with the trigger
	GetHandlers() []Handler
}

InitContext is the initialization context for the trigger instance

type Metadata

type Metadata struct {
	Settings        map[string]data.TypedValue
	HandlerSettings map[string]data.TypedValue
	Output          map[string]data.TypedValue
	Reply           map[string]data.TypedValue
	Event           map[string]data.TypedValue
	//DEPRECATED
	ID string
}

func NewMetadata

func NewMetadata(mdStructs ...interface{}) *Metadata

type SchemaConfig

type SchemaConfig struct {
	Output map[string]interface{} `json:"output,omitempty"`
	Reply  map[string]interface{} `json:"reply,omitempty"`
}

type Trigger

type Trigger interface {
	managed.Managed

	// Initialize is called to initialize the Trigger
	Initialize(ctx InitContext) error
}

Trigger is object that triggers/starts flow instances and is managed by an engine