change

type Node ¶

type Node struct {
	Path      []NodeDetail
	HandlerFn func(from, to interface{}, path *Node) error
}

Node in the object graph which if present should result in the HandlerFn being invoked where HandlerFn takes a resource objects current and desired states, with the provider responsible for testing equality and subsequent handling of any required changes to the resource.

For example, say you have the following types:

type Car struct {
	Make string
	Age  int
	Fuel Fuel
}

type Fuel struct {
	Make     string
	Unleaded bool
}

You can create a change node with handler function for the Unleaded field in a Car object as follows.

handler := func(have, want interface{}, path *change.Node) error {
    fmt.Printf("Handle the change here")
}
node := NewNode().Field("Fuel").Field("Unleaded").Handler(handler)

The handler function can be a closure to include additional objects such as API clients, look at the digitalocean package for an example of this.

func NewNode() *Node

func (n *Node) Field(name string) *Node

func (n *Node) Handle(from, to interface{}) error

func (n *Node) Handler(f func(from, to interface{}, path *Node) error) *Node

func (n *Node) Index(id int) *Node

func (n *Node) Key(key interface{}) *Node

type NodeDetail ¶

type NodeDetail struct {
	Field string
	Index int
	Key   interface{}
	Type  string
}

NodeDetail describes an individual node in the path to the target Node above, navigating the object graph via struct fields, map keys or slice/array indices.

type Registry ¶

type Registry struct {
	sync.Mutex
	// contains filtered or unexported fields
}

Registry stores a list of change nodes to be evaluated

func NewRegistry() *Registry

func (r *Registry) Add(n *Node)

func (r *Registry) HandleChanges(from, to interface{}) error

func (r *Registry) SetLogger(logger hclog.Logger)