seems to compile

Signed-off-by: Jeff Carr <[email protected]>

1 files changed, 12 insertions, 65 deletions

diff --git a/config.go b/config.go
index 7973da9..8fc9d27 100644
--- a/config.go
+++ b/config.go
@@ -16,7 +16,7 @@ import (
 
 // writes out the cluster information it seperate files
 // to make it humanly possible to hand edit things as needed
-func (c *Cluster) ConfigSave() error {
+func (c *NewCluster) ConfigSave() error {
 	// try to backup the current cluster config files
 	if err := backupConfig(); err != nil {
 		return err
@@ -25,9 +25,8 @@ func (c *Cluster) ConfigSave() error {
 	// make a new droplets struct
 	var d *Droplets
 	d = new(Droplets)
-	d.Droplets = c.Droplets
 	// copy all the records over to the new struct
-	for _, drop := range c.Droplets {
+	for _, drop := range c.d.Droplets {
 		d.Droplets = append(d.Droplets, drop)
 	}
 	// delete all the Current data so it's not put in the config file
@@ -43,83 +42,42 @@ func (c *Cluster) ConfigSave() error {
 		return err
 	}
 
-	var h *Hypervisors
-	h = new(Hypervisors)
-	h.Hypervisors = c.Hypervisors
-	if err := ConfigWriteJSON(h, "hypervisors.json"); err != nil {
+	if err := ConfigWriteJSON(c.h, "hypervisors.json"); err != nil {
 		fmt.Println("hypervisors.json write failed")
 		return err
 	}
-	if err := ConfigWriteTEXT(h, "hypervisors.text"); err != nil {
+	if err := ConfigWriteTEXT(c.h, "hypervisors.text"); err != nil {
 		fmt.Println("hypervisors.json write failed")
 		return err
 	}
 
-	if err := ConfigWriteJSON(c.E, "events.json"); err != nil {
+	if err := ConfigWriteJSON(c.e, "events.json"); err != nil {
 		fmt.Println("events.json write failed")
 		return err
 	}
-	if err := ConfigWriteTEXT(c.E, "events.text"); err != nil {
+	if err := ConfigWriteTEXT(c.e, "events.text"); err != nil {
 		fmt.Println("events.json write failed")
 		return err
 	}
-
-	if err := ConfigWriteTEXT(c, "cluster.full.text"); err != nil {
-		fmt.Println("Cluster.json write failed")
-		return err
-	}
-
-	var newc Cluster
-	newc.Dirs = c.Dirs
-	newc.Droplets = nil
-	newc.Hypervisors = nil
-	newc.E = nil
-	if err := ConfigWriteTEXT(&newc, "cluster.text"); err != nil {
-		fmt.Println("cluster.json write failed")
-		return err
-	}
-
 	return nil
 }
 
-func (c *Cluster) ConfigLoad() error {
+func (c *NewCluster) ConfigLoad() error {
 	if c == nil {
 		return errors.New("It's not safe to run ConfigLoad() on a nil cluster")
 	}
 
-	// load the cluster config file
-	if data, err := loadFile("cluster.text"); err == nil {
-		if err = prototext.Unmarshal(data, c); err != nil {
-			fmt.Println("broken cluster.text config file")
-			fmt.Println(err)
-			return errors.New("cluster.text file is broken")
-		}
-	} else {
-		return err
-	}
-
-	var d *Droplets
-	d = new(Droplets)
-	// load the droplet config file
 	if data, err := loadFile("droplets.json"); err == nil {
-		if err = protojson.Unmarshal(data, d); err != nil {
+		if err = protojson.Unmarshal(data, c.d); err != nil {
 			fmt.Println("broken droplets.json config file")
 			return err
 		}
 	} else {
 		return err
 	}
-	// copy them over. is this needed? does the memory free otherwise?
-	// also set initial values
-	for _, drop := range d.Droplets {
-		c.Droplets = append(c.Droplets, drop)
-	}
 
-	var h *Hypervisors
-	h = new(Hypervisors)
-	// load the hypervisors config file
 	if data, err := loadFile("hypervisors.json"); err == nil {
-		if err = protojson.Unmarshal(data, h); err != nil {
+		if err = protojson.Unmarshal(data, c.h); err != nil {
 			fmt.Println("broken hypervisors.json config file")
 			return err
 		}
@@ -127,26 +85,15 @@ func (c *Cluster) ConfigLoad() error {
 		fmt.Println("ERROR HERE IN Hypervisors")
 		return err
 	}
-	// copy them over. is this needed? does the memory free otherwise?
-	for _, a := range h.Hypervisors {
-		c.Hypervisors = append(c.Hypervisors, a)
-	}
 
-	var e *Events
-	e = new(Events)
-
-	if c.E == nil {
+	if c.e == nil {
 		// this seems to panic on nil. something is wrong about doing this
 		// does it not stay allocated after this function ends?
-		c.E = new(Events)
+		c.e = new(Events)
 	}
-	if err := e.loadEvents(); err != nil {
+	if err := c.e.loadEvents(); err != nil {
 		return err
 	}
-	// copy them over. is this needed? does the memory free otherwise?
-	for _, e := range e.Events {
-		c.E.Events = append(c.E.Events, e)
-	}
 	return nil
 }