engine: Resources package rewrite

This giant patch makes some much needed improvements to the code base.

* The engine has been rewritten and lives within engine/graph/
* All of the common interfaces and code now live in engine/
* All of the resources are in one package called engine/resources/
* The Res API can use different "traits" from engine/traits/
* The Res API has been simplified to hide many of the old internals
* The Watch & Process loops were previously inverted, but is now fixed
* The likelihood of package cycles has been reduced drastically
* And much, much more...

Unfortunately, some code had to be temporarily removed. The remote code
had to be taken out, as did the prometheus code. We hope to have these
back in new forms as soon as possible.

engine/resources/timer.go

@@ -0,0 +1,182 @@
+// Mgmt
+// Copyright (C) 2013-2018+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package resources
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/purpleidea/mgmt/engine"
+	"github.com/purpleidea/mgmt/engine/traits"
+)
+
+func init() {
+	engine.RegisterResource("timer", func() engine.Res { return &TimerRes{} })
+}
+
+// TimerRes is a timer resource for time based events. It outputs an event every
+// interval seconds.
+type TimerRes struct {
+	traits.Base // add the base methods without re-implementation
+	traits.Refreshable
+
+	init *engine.Init
+
+	Interval uint32 `yaml:"interval"` // interval between runs in seconds
+
+	ticker *time.Ticker
+}
+
+// Default returns some sensible defaults for this resource.
+func (obj *TimerRes) Default() engine.Res {
+	return &TimerRes{}
+}
+
+// Validate the params that are passed to TimerRes.
+func (obj *TimerRes) Validate() error {
+	return nil
+}
+
+// Init runs some startup code for this resource.
+func (obj *TimerRes) Init(init *engine.Init) error {
+	obj.init = init // save for later
+
+	return nil
+}
+
+// Close is run by the engine to clean up after the resource is done.
+func (obj *TimerRes) Close() error {
+	return nil
+}
+
+// newTicker creates a new ticker
+func (obj *TimerRes) newTicker() *time.Ticker {
+	return time.NewTicker(time.Duration(obj.Interval) * time.Second)
+}
+
+// Watch is the primary listener for this resource and it outputs events.
+func (obj *TimerRes) Watch() error {
+	// create a time.Ticker for the given interval
+	obj.ticker = obj.newTicker()
+	defer obj.ticker.Stop()
+
+	// notify engine that we're running
+	if err := obj.init.Running(); err != nil {
+		return err // exit if requested
+	}
+
+	var send = false // send event?
+	for {
+		select {
+		case <-obj.ticker.C: // received the timer event
+			send = true
+			obj.init.Logf("received tick")
+
+		case event, ok := <-obj.init.Events:
+			if !ok {
+				return nil
+			}
+			if err := obj.init.Read(event); err != nil {
+				return err
+			}
+		}
+
+		if send {
+			send = false
+			if err := obj.init.Event(); err != nil {
+				return err // exit if requested
+			}
+		}
+	}
+}
+
+// CheckApply method for Timer resource. Triggers a timer reset on notify.
+func (obj *TimerRes) CheckApply(apply bool) (bool, error) {
+	// because there are no checks to run, this resource has a less
+	// traditional pattern than what is seen in most resources...
+	if !obj.init.Refresh() { // this works for apply || !apply
+		return true, nil // state is always okay if no refresh to do
+	} else if !apply { // we had a refresh to do
+		return false, nil // therefore state is wrong
+	}
+
+	// reset the timer since apply && refresh
+	obj.ticker.Stop()
+	obj.ticker = obj.newTicker()
+	return false, nil
+}
+
+// Cmp compares two resources and returns an error if they are not equivalent.
+func (obj *TimerRes) Cmp(r engine.Res) error {
+	if !obj.Compare(r) {
+		return fmt.Errorf("did not compare")
+	}
+	return nil
+}
+
+// Compare two resources and return if they are equivalent.
+func (obj *TimerRes) Compare(r engine.Res) bool {
+	// we can only compare TimerRes to others of the same resource kind
+	res, ok := r.(*TimerRes)
+	if !ok {
+		return false
+	}
+
+	if obj.Interval != res.Interval {
+		return false
+	}
+
+	return true
+}
+
+// TimerUID is the UID struct for TimerRes.
+type TimerUID struct {
+	engine.BaseUID
+
+	name string
+}
+
+// UIDs includes all params to make a unique identification of this object.
+// Most resources only return one, although some resources can return multiple.
+func (obj *TimerRes) UIDs() []engine.ResUID {
+	x := &TimerUID{
+		BaseUID: engine.BaseUID{Name: obj.Name(), Kind: obj.Kind()},
+		name:    obj.Name(),
+	}
+	return []engine.ResUID{x}
+}
+
+// UnmarshalYAML is the custom unmarshal handler for this struct.
+// It is primarily useful for setting the defaults.
+func (obj *TimerRes) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	type rawRes TimerRes // indirection to avoid infinite recursion
+
+	def := obj.Default()       // get the default
+	res, ok := def.(*TimerRes) // put in the right format
+	if !ok {
+		return fmt.Errorf("could not convert to TimerRes")
+	}
+	raw := rawRes(*res) // convert; the defaults go here
+
+	if err := unmarshal(&raw); err != nil {
+		return err
+	}
+
+	*obj = TimerRes(raw) // restore from indirection with type conversion!
+	return nil
+}