routers

Documentation

Index

• Constants
• func RouterFromEnvelope(envelope *utils.TypedEnvelope) (flows.Router, error)
• type BaseRouter
  • func (r *BaseRouter) ResultName() string
• type Case
• type FirstRouter
  • func NewFirstRouter(resultName string) *FirstRouter
  • func (r *FirstRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)
  • func (r *FirstRouter) Type() string
  • func (r *FirstRouter) Validate(exits []flows.Exit) error
• type RandomOnceRouter
  • func NewRandomOnceRouter(exit flows.ExitUUID, resultName string) *RandomOnceRouter
  • func (r *RandomOnceRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)
  • func (r *RandomOnceRouter) Type() string
  • func (r *RandomOnceRouter) Validate(exits []flows.Exit) error
• type RandomRouter
  • func NewRandomRouter(resultName string) *RandomRouter
  • func (r *RandomRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)
  • func (r *RandomRouter) Type() string
  • func (r *RandomRouter) Validate(exits []flows.Exit) error
• type SwitchRouter
  • func NewSwitchRouter(defaultExit flows.ExitUUID, operand string, cases []Case, resultName string) *SwitchRouter
  • func (r *SwitchRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)
  • func (r *SwitchRouter) Type() string
  • func (r *SwitchRouter) Validate(exits []flows.Exit) error

Constants

const TypeFirst string = "first"

TypeFirst is the type for FirstRouters

const TypeRandom string = "random"

TypeRandom is the type for a random router

const TypeRandomOnce string = "random_once"

TypeRandomOnce is the constant for our random once router

const TypeSwitch string = "switch"

TypeSwitch is the constant for our switch router

Functions

func RouterFromEnvelope

func RouterFromEnvelope(envelope *utils.TypedEnvelope) (flows.Router, error)

RouterFromEnvelope attempts to build a router given the passed in TypedEnvelope

Types

type BaseRouter

type BaseRouter struct {
	// ResultName_ is the name of the which the result of this router should be saved as (if any)
	ResultName_ string `json:"result_name,omitempty"`
}

BaseRouter is the base class for all our router classes

func (*BaseRouter) ResultName

func (r *BaseRouter) ResultName() string

ResultName returns the name which the result of this router should be saved as (if any)

type Case

type Case struct {
	UUID        utils.UUID     `json:"uuid"                 validate:"required"`
	Type        string         `json:"type"                 validate:"required"`
	Arguments   []string       `json:"arguments,omitempty"`
	OmitOperand bool           `json:"omit_operand,omitempty"`
	ExitUUID    flows.ExitUUID `json:"exit_uuid"            validate:"required"`
}

Case represents a single case and test in our switch

type FirstRouter

type FirstRouter struct {
	BaseRouter
}

FirstRouter is a simple router that always takes the first exit

func NewFirstRouter

func NewFirstRouter(resultName string) *FirstRouter

func (*FirstRouter) PickRoute

func (r *FirstRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)

PickRoute always picks the first exit if available for this router

func (*FirstRouter) Type

func (r *FirstRouter) Type() string

Type returns the type of this router

func (*FirstRouter) Validate

func (r *FirstRouter) Validate(exits []flows.Exit) error

Validate validates the arguments on this router

type RandomOnceRouter

type RandomOnceRouter struct {
	BaseRouter
	Exit flows.ExitUUID `json:"exit"     validate:"required"`
}

RandomOnceRouter exits of our exits once (randomly) before taking exit

func NewRandomOnceRouter

func NewRandomOnceRouter(exit flows.ExitUUID, resultName string) *RandomOnceRouter

func (*RandomOnceRouter) PickRoute

func (r *RandomOnceRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)

PickRoute will attempt to take a random exit it hasn't taken before. If all exits have been taken, then it will take the exit specified in it's Exit parameter

func (*RandomOnceRouter) Type

func (r *RandomOnceRouter) Type() string

Type returns the type of our router

func (*RandomOnceRouter) Validate

func (r *RandomOnceRouter) Validate(exits []flows.Exit) error

Validate validates the parameters on this router

type RandomRouter

type RandomRouter struct {
	BaseRouter
}

RandomRouter is a router which will exit out a random exit

func NewRandomRouter

func NewRandomRouter(resultName string) *RandomRouter

func (*RandomRouter) PickRoute

func (r *RandomRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)

PickRoute picks a route randomly from our available exits

func (*RandomRouter) Type

func (r *RandomRouter) Type() string

Type returns the type of this router

func (*RandomRouter) Validate

func (r *RandomRouter) Validate(exits []flows.Exit) error

Validate validates that the fields on this router are valid

type SwitchRouter

type SwitchRouter struct {
	BaseRouter
	Default flows.ExitUUID `json:"default_exit_uuid"   validate:"omitempty,uuid4"`
	Operand string         `json:"operand"             validate:"required"`
	Cases   []Case         `json:"cases"`
}

SwitchRouter is a router which allows specifying 0-n cases which should each be tested in order, following whichever case returns true, or if none do, then taking the default exit

func NewSwitchRouter

func NewSwitchRouter(defaultExit flows.ExitUUID, operand string, cases []Case, resultName string) *SwitchRouter

func (*SwitchRouter) PickRoute

func (r *SwitchRouter) PickRoute(run flows.FlowRun, exits []flows.Exit, step flows.Step) (string, flows.Route, error)

PickRoute evaluates each of the tests on our cases in order, returning the exit for the first case which evaluates to a true. If no cases evaluate to true, then the default exit (if specified) is returned

func (*SwitchRouter) Type

func (r *SwitchRouter) Type() string

Type returns the type of this router

func (*SwitchRouter) Validate

func (r *SwitchRouter) Validate(exits []flows.Exit) error

Validate validates the arguments for this router