gapi: Split out graph generation into a proper graph API

This is a monster patch that splits out the yaml and puppet based graph
generation and pushes them behind a common API. In addition alternate
pluggable GAPI's can be easily added! The important side benefit is that
you can now write a custom GAPI for embedding mgmt!

This also includes some slight clean ups that I didn't find it worth
splitting into separate patches.

examples/lib/libmgmt1.go

@@ -6,24 +6,66 @@ import (
 	"log"
 	"os"
 	"os/signal"
+	"sync"
 	"syscall"
 	"time"
 
-	"github.com/purpleidea/mgmt/gconfig"
+	"github.com/purpleidea/mgmt/gapi"
 	mgmt "github.com/purpleidea/mgmt/mgmtmain"
+	"github.com/purpleidea/mgmt/pgraph"
 	"github.com/purpleidea/mgmt/resources"
+	"github.com/purpleidea/mgmt/yamlgraph"
 )
 
-func generateGraphConfig() *gconfig.GraphConfig {
+// MyGAPI implements the main GAPI interface.
+type MyGAPI struct {
+	Name     string // graph name
+	Interval uint   // refresh interval, 0 to never refresh
+
+	data        gapi.Data
+	initialized bool
+	closeChan   chan struct{}
+	wg          sync.WaitGroup // sync group for tunnel go routines
+}
+
+// NewMyGAPI creates a new MyGAPI struct and calls Init().
+func NewMyGAPI(data gapi.Data, name string, interval uint) (*MyGAPI, error) {
+	obj := &MyGAPI{
+		Name:     name,
+		Interval: interval,
+	}
+	return obj, obj.Init(data)
+}
+
+// Init initializes the MyGAPI struct.
+func (obj *MyGAPI) Init(data gapi.Data) error {
+	if obj.initialized {
+		return fmt.Errorf("Already initialized!")
+	}
+	if obj.Name == "" {
+		return fmt.Errorf("The graph name must be specified!")
+	}
+	obj.data = data // store for later
+	obj.closeChan = make(chan struct{})
+	obj.initialized = true
+	return nil
+}
+
+// Graph returns a current Graph.
+func (obj *MyGAPI) Graph() (*pgraph.Graph, error) {
+	if !obj.initialized {
+		return nil, fmt.Errorf("libmgmt: MyGAPI is not initialized")
+	}
 
 	n1, err := resources.NewNoopRes("noop1")
 	if err != nil {
-		return nil // error
+		return nil, fmt.Errorf("Can't create resource: %v", err)
 	}
 
-	gc := &gconfig.GraphConfig{
-		Graph: "libmgmt",
-		Resources: gconfig.Resources{ // must redefine anonymous struct :(
+	// we can still build a graph via the yaml method
+	gc := &yamlgraph.GraphConfig{
+		Graph: obj.Name,
+		Resources: yamlgraph.Resources{ // must redefine anonymous struct :(
 			// in alphabetical order
 			Exec:  []*resources.ExecRes{},
 			File:  []*resources.FileRes{},
@@ -37,38 +79,74 @@ func generateGraphConfig() *gconfig.GraphConfig {
 		//Collector: []collectorResConfig{},
 		//Edges:     []Edge{},
 		Comment: "comment!",
-		//Hostname: "???",
-		//Remote: "???",
 	}
-	return gc
+
+	g, err := gc.NewGraphFromConfig(obj.data.Hostname, obj.data.EmbdEtcd, obj.data.Noop)
+	return g, err
+}
+
+// SwitchStream returns nil errors every time there could be a new graph.
+func (obj *MyGAPI) SwitchStream() chan error {
+	if obj.data.NoWatch || obj.Interval <= 0 {
+		return nil
+	}
+	ch := make(chan error)
+	obj.wg.Add(1)
+	go func() {
+		defer obj.wg.Done()
+		defer close(ch) // this will run before the obj.wg.Done()
+		if !obj.initialized {
+			ch <- fmt.Errorf("libmgmt: MyGAPI is not initialized")
+			return
+		}
+
+		// arbitrarily change graph every interval seconds
+		ticker := time.NewTicker(time.Duration(obj.Interval) * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				log.Printf("libmgmt: Generating new graph...")
+				ch <- nil // trigger a run
+			case <-obj.closeChan:
+				return
+			}
+		}
+	}()
+	return ch
+}
+
+// Close shuts down the MyGAPI.
+func (obj *MyGAPI) Close() error {
+	if !obj.initialized {
+		return fmt.Errorf("libmgmt: MyGAPI is not initialized")
+	}
+	close(obj.closeChan)
+	obj.wg.Wait()
+	obj.initialized = false // closed = true
+	return nil
 }
 
 // Run runs an embedded mgmt server.
 func Run() error {
 
 	obj := &mgmt.Main{}
-	obj.Program = "mgmtlib" // TODO: set on compilation
+	obj.Program = "libmgmt" // TODO: set on compilation
 	obj.Version = "0.0.1"   // TODO: set on compilation
 	obj.TmpPrefix = true
 	obj.IdealClusterSize = -1
 	obj.ConvergedTimeout = -1
 	obj.Noop = true
 
-	obj.GAPI = generateGraphConfig // graph API function
+	obj.GAPI = &MyGAPI{ // graph API
+		Name:     "libmgmt", // TODO: set on compilation
+		Interval: 15,        // arbitrarily change graph every 15 seconds
+	}
 
 	if err := obj.Init(); err != nil {
 		return err
 	}
 
-	go func() {
-		for {
-			log.Printf("Generating new graph...")
-			obj.Switch(generateGraphConfig) // pass in function to run...
-
-			time.Sleep(15 * time.Second) // XXX: arbitrarily change graph every 30 seconds
-		}
-	}()
-
 	// install the exit signal handler
 	exit := make(chan struct{})
 	defer close(exit)