directive

Documentation

Index

• Constants
• type Directive
  • func (d *Directive) FQFN(fn string) (string, error)
  • func (d *Directive) Marshal() ([]byte, error)
  • func (d *Directive) Unmarshal(in []byte) error
  • func (d *Directive) Validate() error
• type Executable
  • func (e *Executable) IsFn() bool
  • func (e *Executable) IsGroup() bool
• type Function
• type Handler
• type Input

Constants

const (
	InputTypeRequest = "request"
)

InputTypeRequest and others represent consts for Directives

const (
	NamespaceDefault = "default"
)

NamespaceDefault and others represent conts for namespaces

Types

type Directive

type Directive struct {
	Identifier string     `yaml:"identifier"`
	Version    string     `yaml:"version"`
	Functions  []Function `yaml:"functions"`
	Handlers   []Handler  `yaml:"handlers,omitempty"`
	// contains filtered or unexported fields
}

Directive describes a set of functions and a set of handlers that take an input, and compose a set of functions to handle it

func (*Directive) FQFN

func (d *Directive) FQFN(fn string) (string, error)

FQFN returns the FQFN for a given function in the directive

func (*Directive) Marshal

func (d *Directive) Marshal() ([]byte, error)

Marshal outputs the YAML bytes of the Directive

func (*Directive) Unmarshal

func (d *Directive) Unmarshal(in []byte) error

Unmarshal unmarshals YAML bytes into a Directive struct it also calculates a map of FQFNs for later use

func (*Directive) Validate

func (d *Directive) Validate() error

Validate validates a directive

type Executable

type Executable struct {
	Group []string `yaml:"group,omitempty"`
	Fn    string   `yaml:"fn,omitempty"`
}

Executable represents an executable step in a handler

func (*Executable) IsFn

func (e *Executable) IsFn() bool

IsFn returns true if the executable is a group

func (*Executable) IsGroup

func (e *Executable) IsGroup() bool

IsGroup returns true if the executable is a group

type Function

type Function struct {
	Name      string
	NameSpace string
}

Function describes a function present inside of a bundle

type Handler

type Handler struct {
	Input    Input `yaml:"input,inline"`
	Steps    []Executable
	Response string `yaml:"response,omitempty"`
}

Handler represents the mapping between an input and a composition of functions

type Input

type Input struct {
	Type     string
	Method   string
	Resource string
}

Input represents an input source