Rework the converged detection and provide a clean interface

The old converged detection was hacked in code, instead of something
with a nice interface. This cleans it up, splits it into a separate
file, and removes a race condition that happened with the old code.

We also take the time to get rid of the ugly Set* methods and replace
them all with a single AssociateData method. This might be unnecessary
if we can pass in the Converger method at Resource construction.

Lastly, and most interesting, we suspend the individual timeout callers
when they've already converged, thus reducing unnecessary traffic, and
avoiding fast (eg: < 5 second) timers triggering more than once if they
stay converged!

A quick note on theory for any future readers... What happens if we have
--converged-timeout=0 ? Well, for this and any other positive value,
it's important to realize that deciding if something is converged is
actually a race between if the converged timer will fire and if some
random new event will get triggered. This is because there is nothing
that can actually predict if or when a new event will happen (eg the
user modifying a file). As a result, a race is always inherent, and
actually not a negative or "incorrect" algorithm.

A future improvement could be to add a global lock to each resource, and
to lock all resources when computing if we are converged or not. In
practice, this hasn't been necessary. The worst case scenario would be
(in theory, because this hasn't been tested) if an event happens
*during* the converged calculation, and starts running, the exit command
then runs, and the event finishes, but it doesn't get a chance to notify
some service to restart. A lock could probably fix this theoretical
case.

resources.go

@@ -36,15 +36,6 @@ const (
 	resStatePoking
 )
 
-//go:generate stringer -type=resConvergedState -output=resconvergedstate_stringer.go
-type resConvergedState int
-
-const (
-	resConvergedNil resConvergedState = iota
-	//resConverged
-	resConvergedTimeout
-)
-
 // a unique identifier for a resource, namely it's name, and the kind ("type")
 type ResUUID interface {
 	GetName() string
@@ -78,12 +69,9 @@ type Base interface {
 	SetName(string)
 	Kind() string
 	GetMeta() MetaParams
-	SetVertex(*Vertex)
-	SetConvergedCallback(ctimeout int, converged chan bool)
+	AssociateData(Converger)
 	IsWatching() bool
 	SetWatching(bool)
-	GetConvergedState() resConvergedState
-	SetConvergedState(resConvergedState)
 	GetState() resState
 	SetState(resState)
 	SendEvent(eventName, bool, bool) bool
@@ -110,19 +98,16 @@ type Res interface {
 }
 
 type BaseRes struct {
-	Name           string     `yaml:"name"`
-	Meta           MetaParams `yaml:"meta"` // struct of all the metaparams
-	kind           string
-	events         chan Event
-	vertex         *Vertex
-	state          resState
-	convergedState resConvergedState
-	watching       bool // is Watch() loop running ?
-	ctimeout       int  // converged timeout
-	converged      chan bool
-	isStateOK      bool  // whether the state is okay based on events or not
-	isGrouped      bool  // am i contained within a group?
-	grouped        []Res // list of any grouped resources
+	Name      string     `yaml:"name"`
+	Meta      MetaParams `yaml:"meta"` // struct of all the metaparams
+	kind      string
+	events    chan Event
+	converger Converger // converged tracking
+	state     resState
+	watching  bool  // is Watch() loop running ?
+	isStateOK bool  // whether the state is okay based on events or not
+	isGrouped bool  // am i contained within a group?
+	grouped   []Res // list of any grouped resources
 }
 
 // wraps the IFF method when used with a list of UUID's
@@ -185,17 +170,9 @@ func (obj *BaseRes) GetMeta() MetaParams {
 	return obj.Meta
 }
 
-func (obj *BaseRes) GetVertex() *Vertex {
-	return obj.vertex
-}
-
-func (obj *BaseRes) SetVertex(v *Vertex) {
-	obj.vertex = v
-}
-
-func (obj *BaseRes) SetConvergedCallback(ctimeout int, converged chan bool) {
-	obj.ctimeout = ctimeout
-	obj.converged = converged
+// AssociateData associates some data with the object in question
+func (obj *BaseRes) AssociateData(converger Converger) {
+	obj.converger = converger
 }
 
 // is the Watch() function running?
@@ -208,14 +185,6 @@ func (obj *BaseRes) SetWatching(b bool) {
 	obj.watching = b
 }
 
-func (obj *BaseRes) GetConvergedState() resConvergedState {
-	return obj.convergedState
-}
-
-func (obj *BaseRes) SetConvergedState(state resConvergedState) {
-	obj.convergedState = state
-}
-
 func (obj *BaseRes) GetState() resState {
 	return obj.state
 }