create an error handling system that does the breadcrumb and bugsnag parts correctly

commands/evar/add.go

@@ -1,6 +1,7 @@
 package evar
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/spf13/cobra"
@@ -61,6 +62,8 @@ func parseEvars(args []string) map[string]string {
 			if len(parts) == 2 {
 
 				evars[strings.ToUpper(parts[0])] = parts[1]
+			} else {
+				fmt.Printf("invalid evar (%s)\n", pair)
 			}
 		}
 	}

generators/hooks/code/deploy.go

@@ -9,15 +9,15 @@ import (
 
 type (
 	deploy struct {
-		LogvacHost         string         `json:"logvac_host"`
-		Platform           string         `json:"platform"`
-		Member             map[string]int `json:"member"`
-		Component          component      `json:"component"`
-		BeforeLive         interface{}    `json:"before_live,omitempty"`
-		BeforeLiveAll      interface{}    `json:"before_live_all,omitempty"`
-		AfterLive          interface{}    `json:"after_live,omitempty"`
-		AfterLiveAll       interface{}    `json:"after_live_all,omitempty"`
-		DeployHookTimeout  interface{}    `json:"deploy_hook_timeout,omitempty"`
+		LogvacHost        string         `json:"logvac_host"`
+		Platform          string         `json:"platform"`
+		Member            map[string]int `json:"member"`
+		Component         component      `json:"component"`
+		BeforeLive        interface{}    `json:"before_live,omitempty"`
+		BeforeLiveAll     interface{}    `json:"before_live_all,omitempty"`
+		AfterLive         interface{}    `json:"after_live,omitempty"`
+		AfterLiveAll      interface{}    `json:"after_live_all,omitempty"`
+		DeployHookTimeout interface{}    `json:"deploy_hook_timeout,omitempty"`
 	}
 )
 
@@ -38,7 +38,7 @@ func DeployPayload(appModel *models.App, componentModel *models.Component) strin
 		BeforeLiveAll:     boxfile.Node("deploy.config").Node("before_live_all").Value(componentModel.Name),
 		AfterLive:         boxfile.Node("deploy.config").Node("after_live").Value(componentModel.Name),
 		AfterLiveAll:      boxfile.Node("deploy.config").Node("after_live_all").Value(componentModel.Name),
-		DeployHookTimeout: boxfile.Node("deploy.config").Node("deploy_hook_timeout"),
+		DeployHookTimeout: boxfile.Node("deploy.config").Value("deploy_hook_timeout"),
 	}
 
 	// turn it into json

main.go

@@ -62,7 +62,7 @@ func main() {
 		if !valid {
 			display.MissingDependencies(providerName, missingParts)
 			os.Exit(1)
-		}		
+		}
 	}
 
 	// setup a file logger, this will be replaced in verbose mode.

processors/app/deploy.go

@@ -1,8 +1,6 @@
 package app
 
 import (
-	"fmt"
-
 	"github.com/nanobox-io/nanobox-boxfile"
 
 	generator "github.com/nanobox-io/nanobox/generators/hooks/code"
@@ -11,6 +9,7 @@ import (
 	"github.com/nanobox-io/nanobox/processors/component"
 	"github.com/nanobox-io/nanobox/processors/platform"
 	"github.com/nanobox-io/nanobox/processors/provider"
+	"github.com/nanobox-io/nanobox/util"
 	"github.com/nanobox-io/nanobox/util/display"
 	"github.com/nanobox-io/nanobox/util/hookit"
 )
@@ -20,12 +19,12 @@ func Deploy(envModel *models.Env, appModel *models.App) error {
 
 	// init docker client
 	if err := provider.Init(); err != nil {
-		return fmt.Errorf("failed to init docker client: %s", err.Error())
+		return util.ErrorAppend(err, "failed to init docker client")
 	}
 
 	// syncronize the services as per the new boxfile
 	if err := component.Sync(envModel, appModel); err != nil {
-		return fmt.Errorf("failed to sync components: %s", err.Error())
+		return util.ErrorAppend(err, "failed to sync components")
 	}
 
 	// if the app is a dev app then we should leave here
@@ -35,7 +34,7 @@ func Deploy(envModel *models.Env, appModel *models.App) error {
 
 	// setup the platform services
 	if err := platform.Setup(appModel); err != nil {
-		return fmt.Errorf("failed to setup platform services: %s", err.Error())
+		return util.ErrorAppend(err, "failed to setup platform services")
 	}
 
 	// create the warehouse config for child processes
@@ -49,16 +48,16 @@ func Deploy(envModel *models.Env, appModel *models.App) error {
 
 	// publish the code
 	if err := code.Publish(envModel, warehouseConfig); err != nil {
-		return fmt.Errorf("unable to publish code: %s", err.Error())
+		return util.ErrorAppend(err, "unable to publish code")
 	}
 
 	// start code
 	if err := code.Sync(appModel, warehouseConfig); err != nil {
-		return fmt.Errorf("failed to add code components: %s", err.Error())
+		return util.ErrorAppend(err, "failed to add code components")
 	}
 
 	if err := finalizeDeploy(appModel); err != nil {
-		return fmt.Errorf("failed to finalize deploy: %s", err.Error())
+		return util.ErrorAppend(err, "failed to finalize deploy")
 	}
 
 	// give the user some helpful information
@@ -75,22 +74,22 @@ func finalizeDeploy(appModel *models.App) error {
 	display.StartTask("Running before_live hooks")
 	if err := runDeployHook(appModel, "before_live"); err != nil {
 		display.ErrorTask()
-		return fmt.Errorf("failed to run before deploy hooks: %s", err.Error())
+		return util.ErrorAppend(err, "failed to run before deploy hooks")
 	}
 	display.StopTask()
 
 	// update nanoagent portal
 	display.StartTask("Updating router")
 	if err := platform.UpdatePortal(appModel); err != nil {
 		display.ErrorTask()
-		return fmt.Errorf("failed to update router: %s", err.Error())
+		return util.ErrorAppend(err, "failed to update router")
 	}
 	display.StopTask()
 
 	display.StartTask("Running after_live hooks")
 	if err := runDeployHook(appModel, "after_live"); err != nil {
 		display.ErrorTask()
-		return fmt.Errorf("failed to run after deloy hooks: %s", err.Error())
+		return util.ErrorAppend(err, "failed to run after deloy hooks")
 	}
 	display.StopTask()
 

processors/app/destroy.go

@@ -11,6 +11,7 @@ import (
 	"github.com/nanobox-io/nanobox/processors/app/dns"
 	"github.com/nanobox-io/nanobox/processors/component"
 	"github.com/nanobox-io/nanobox/processors/provider"
+	"github.com/nanobox-io/nanobox/util"
 	"github.com/nanobox-io/nanobox/util/dhcp"
 	"github.com/nanobox-io/nanobox/util/display"
 	"github.com/nanobox-io/nanobox/util/locker"
@@ -20,7 +21,7 @@ import (
 func Destroy(appModel *models.App) error {
 	// init docker client
 	if err := provider.Init(); err != nil {
-		return fmt.Errorf("failed to init docker client: %s", err.Error())
+		return util.ErrorAppend(err, "failed to init docker client")
 	}
 
 	locker.LocalLock()
@@ -34,12 +35,12 @@ func Destroy(appModel *models.App) error {
 	// load the env for the display context
 	envModel, err := appModel.Env()
 	if err != nil {
-		lumber.Error("app:Start:models.App.Env(): %s", err.Error())
-		return fmt.Errorf("failed to load app env: %s", err.Error())
+		lumber.Error("app:Start:models.App.Env()")
+		return util.ErrorAppend(err, "failed to load app env")
 	}
 
 	if err := dns.RemoveAll(appModel); err != nil {
-		return fmt.Errorf("failed to remove dns aliases")
+		return util.ErrorAppend(err, "failed to remove dns aliases")
 	}
 
 	display.OpenContext("%s (%s)", envModel.Name, appModel.DisplayName())
@@ -50,18 +51,18 @@ func Destroy(appModel *models.App) error {
 
 	// destroy the associated components
 	if err := destroyComponents(appModel); err != nil {
-		return fmt.Errorf("failed to destroy components: %s", err.Error())
+		return util.ErrorAppend(err, "failed to destroy components")
 	}
 
 	// release IPs
 	if err := releaseIPs(appModel); err != nil {
-		return fmt.Errorf("failed to release IPs: %s", err.Error())
+		return util.ErrorAppend(err, "failed to release IPs")
 	}
 
 	// destroy the app model
 	if err := appModel.Delete(); err != nil {
 		lumber.Error("app:Destroy:models.App{ID:%s}.Destroy(): %s", appModel.ID, err.Error())
-		return fmt.Errorf("failed to delete app model: %s", err.Error())
+		return util.ErrorAppend(err, "failed to delete app model")
 	}
 
 	return nil
@@ -75,7 +76,7 @@ func destroyComponents(appModel *models.App) error {
 	componentModels, err := appModel.Components()
 	if err != nil {
 		lumber.Error("app:destroyComponents:models.App{ID:%s}.Components() %s", appModel.ID, err.Error())
-		return fmt.Errorf("unable to retrieve components: %s", err.Error())
+		return util.ErrorAppend(err, "unable to retrieve components")
 	}
 
 	if len(componentModels) == 0 {
@@ -86,7 +87,7 @@ func destroyComponents(appModel *models.App) error {
 
 	for _, componentModel := range componentModels {
 		if err := component.Destroy(appModel, componentModel); err != nil {
-			return fmt.Errorf("failed to destroy app component: %s", err.Error())
+			return util.ErrorAppend(err, "failed to destroy app component")
 		}
 	}
 
@@ -104,7 +105,7 @@ func releaseIPs(appModel *models.App) error {
 		if err := dhcp.ReturnIP(net.ParseIP(ip)); err != nil {
 			display.ErrorTask()
 			lumber.Error("app:Destroy:releaseIPs:dhcp.ReturnIP(%s): %s", ip, err.Error())
-			return fmt.Errorf("failed to release IP: %s", err.Error())
+			return util.ErrorAppend(err, "failed to release IP")
 		}
 	}
 

processors/app/dns/add.go

@@ -18,7 +18,7 @@ var AppSetup func(envModel *models.Env, appModel *models.App, name string) error
 func Add(envModel *models.Env, appModel *models.App, name string) error {
 
 	if err := AppSetup(envModel, appModel, appModel.Name); err != nil {
-		return fmt.Errorf("failed to setup app: %s", err)
+		return util.ErrorAppend(err, "failed to setup app")
 	}
 
 	// fetch the IP
@@ -42,7 +42,7 @@ func Add(envModel *models.Env, appModel *models.App, name string) error {
 	// add the entry
 	if err := dns.Add(entry); err != nil {
 		lumber.Error("dns:Add:dns.Add(%s): %s", entry, err.Error())
-		return fmt.Errorf("unable to add dns entry: %s", err.Error())
+		return util.ErrorAppend(err, "unable to add dns entry")
 	}
 
 	fmt.Printf("\n%s %s added\n\n", display.TaskComplete, name)

processors/app/dns/remove.go

@@ -35,7 +35,7 @@ func Remove(a *models.App, name string) error {
 	// remove the entry
 	if err := dns.Remove(entry); err != nil {
 		lumber.Error("dns:Remove:dns.Remove(%s): %s", entry, err.Error())
-		return fmt.Errorf("unable to add dns entry: %s", err.Error())
+		return util.ErrorAppend(err, "unable to add dns entry: %s")
 	}
 
 	fmt.Printf("\n%s %s removed\n\n", display.TaskComplete, name)

processors/app/dns/remove_all.go

@@ -28,7 +28,7 @@ func RemoveAll(a *models.App) error {
 
 	if err := dns.Remove(a.ID); err != nil {
 		lumber.Error("dns:RemoveAll:dns.Remove(%s): %s", a.ID, err.Error())
-		return fmt.Errorf("failed to remove all dns entries: %s", err.Error())
+		return util.ErrorAppend(err, "failed to remove all dns entries")
 	}
 
 	return nil

processors/app/evar/add.go

@@ -5,13 +5,14 @@ import (
 
 	"github.com/nanobox-io/nanobox/models"
 	"github.com/nanobox-io/nanobox/processors/app"
+	"github.com/nanobox-io/nanobox/util"
 	"github.com/nanobox-io/nanobox/util/display"
 )
 
 func Add(envModel *models.Env, appModel *models.App, evars map[string]string) error {
 
 	if err := app.Setup(envModel, appModel, appModel.Name); err != nil {
-		return fmt.Errorf("failed to setup app: %s", err)
+		return util.ErrorAppend(err, "failed to setup app")
 	}
 
 	// iterate through the evars and add them to the app
@@ -21,7 +22,7 @@ func Add(envModel *models.Env, appModel *models.App, evars map[string]string) er
 
 	// save the app
 	if err := appModel.Save(); err != nil {
-		return fmt.Errorf("failed to persist evars: %s", err.Error())
+		return util.ErrorAppend(err, "failed to persist evars")
 	}
 
 	// iterate one more time for display

processors/app/evar/remove.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/nanobox-io/nanobox/models"
+	"github.com/nanobox-io/nanobox/util"
 	"github.com/nanobox-io/nanobox/util/display"
 )
 
@@ -16,7 +17,7 @@ func Remove(appModel *models.App, keys []string) error {
 
 	// persist the app model
 	if err := appModel.Save(); err != nil {
-		return fmt.Errorf("failed to delete evars: %s", err.Error())
+		return util.ErrorAppend(err, "failed to delete evars")
 	}
 
 	// print the deleted keys

processors/app/setup.go

@@ -1,12 +1,11 @@
 package app
 
 import (
-	"fmt"
-
 	"github.com/jcelliott/lumber"
 
 	"github.com/nanobox-io/nanobox/models"
 	"github.com/nanobox-io/nanobox/processors/app/dns"
+	"github.com/nanobox-io/nanobox/util"
 	"github.com/nanobox-io/nanobox/util/dhcp"
 	"github.com/nanobox-io/nanobox/util/display"
 	"github.com/nanobox-io/nanobox/util/locker"
@@ -29,20 +28,20 @@ func Setup(envModel *models.Env, appModel *models.App, name string) error {
 	// generate the app data
 	if err := appModel.Generate(envModel, name); err != nil {
 		lumber.Error("app:Setup:models.App:Generate(): %s", err.Error())
-		return fmt.Errorf("failed to generate app data: %s", err.Error())
+		return util.ErrorAppend(err, "failed to generate app data")
 	}
 
 RESERVE:
 	// reserve IPs
 	if err := reserveIPs(appModel); err != nil {
-		return fmt.Errorf("failed to reserve app IPs: %s", err.Error())
+		return util.ErrorAppend(err, "failed to reserve app IPs")
 	}
 
 	// set app state to active
 	appModel.State = "active"
 	if err := appModel.Save(); err != nil {
-		lumber.Error("app:Setup:models:App:Save(): %s", err.Error())
-		return fmt.Errorf("failed to persist app state: %s", err.Error())
+		lumber.Error("app:Setup:models:App:Save()")
+		return util.ErrorAppend(err, "failed to persist app state")
 	}
 
 	return nil
@@ -63,8 +62,8 @@ func reserveIPs(appModel *models.App) error {
 		envIP, err := dhcp.ReserveLocal()
 		if err != nil {
 			display.ErrorTask()
-			lumber.Error("app:reserveIPs:dhcp.ReserveLocal(): %s", err.Error())
-			return fmt.Errorf("failed to reserve an env IP: %s", err.Error())
+			lumber.Error("app:reserveIPs:dhcp.ReserveLocal()")
+			return util.ErrorAppend(err, "failed to reserve an env IP")
 		}
 
 		// now assign the IPs onto the app model
@@ -78,8 +77,8 @@ func reserveIPs(appModel *models.App) error {
 			logvacIP, err := dhcp.ReserveLocal()
 			if err != nil {
 				display.ErrorTask()
-				lumber.Error("app:reserveIPs:dhcp.ReserveLocal(): %s", err.Error())
-				return fmt.Errorf("failed to reserve a logvac IP: %s", err.Error())
+				lumber.Error("app:reserveIPs:dhcp.ReserveLocal()")
+				return util.ErrorAppend(err, "failed to reserve a logvac IP")
 			}
 			appModel.LocalIPs["logvac"] = logvacIP.String()
 
@@ -91,7 +90,7 @@ func reserveIPs(appModel *models.App) error {
 			if err != nil {
 				display.ErrorTask()
 				lumber.Error("app:reserveIPs:dhcp.ReserveLocal(): %s", err.Error())
-				return fmt.Errorf("failed to reserve a mist IP: %s", err.Error())
+				return util.ErrorAppend(err, "failed to reserve a mist IP: %s", err.Error())
 			}
 
 			appModel.LocalIPs["mist"] = mistIP.String()
@@ -104,7 +103,7 @@ func reserveIPs(appModel *models.App) error {
 	if err := appModel.Save(); err != nil {
 		display.ErrorTask()
 		lumber.Error("app:reserveIPs:models:App:Save(): %s", err.Error())
-		return fmt.Errorf("failed to persist IPs to the db: %s", err.Error())
+		return util.ErrorAppend(err, "failed to persist IPs to the db: %s", err.Error())
 	}
 
 	return nil