initial draft of detailed errors

Author: msvechla

cli/cli_app.go

@@ -742,7 +742,20 @@ func applyAll(terragruntOptions *options.TerragruntOptions) error {
 	}
 
 	if shouldApplyAll {
-		return stack.Apply(terragruntOptions)
+		stack.SetupErrorChannel()
+		go stack.CollectModuleErrors()
+		err := stack.Apply(terragruntOptions)
+		close(stack.ErrorChan)
+
+		terragruntOptions.Logger.Printf("Encountered the following root-causes: \n")
+		for module, errList := range stack.ErrorMap {
+			terragruntOptions.Logger.Printf("Module: %s \n", module)
+			for _, err := range errList {
+				terragruntOptions.Logger.Printf("- %s \n", err)
+			}
+		}
+
+		return err
 	}
 
 	return nil

configstack/module.go

@@ -27,6 +27,7 @@ type TerraformModule struct {
 	TerragruntOptions    *options.TerragruntOptions
 	AssumeAlreadyApplied bool
 	FlagExcluded         bool
+	ErrorChan            chan map[string]error
 }
 
 // Render this module as a human-readable string

configstack/running_module.go

@@ -1,7 +1,9 @@
 package configstack
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"strings"
 	"sync"
 
@@ -27,6 +29,9 @@ type runningModule struct {
 	Dependencies   map[string]*runningModule
 	NotifyWhenDone []*runningModule
 	FlagExcluded   bool
+	ErrorChan      chan map[string]error
+	OutStream      bytes.Buffer
+	Writer         io.Writer
 }
 
 // This controls in what order dependencies should be enforced between modules
@@ -48,6 +53,8 @@ func newRunningModule(module *TerraformModule) *runningModule {
 		Dependencies:   map[string]*runningModule{},
 		NotifyWhenDone: []*runningModule{},
 		FlagExcluded:   module.FlagExcluded,
+		ErrorChan:      module.ErrorChan,
+		Writer:         module.TerragruntOptions.Writer,
 	}
 }
 
@@ -130,6 +137,8 @@ func removeFlagExcluded(modules map[string]*runningModule) map[string]*runningMo
 				Err:            module.Err,
 				NotifyWhenDone: module.NotifyWhenDone,
 				Status:         module.Status,
+				ErrorChan:      module.ErrorChan,
+				Writer:         module.Module.TerragruntOptions.Writer,
 			}
 
 			// Only add dependencies that should not be excluded
@@ -154,6 +163,8 @@ func runModules(modules map[string]*runningModule) error {
 		waitGroup.Add(1)
 		go func(module *runningModule) {
 			defer waitGroup.Done()
+			module.Module.TerragruntOptions.Writer = &module.OutStream
+			module.Module.TerragruntOptions.ErrWriter = &module.OutStream
 			module.runModuleWhenReady()
 		}(module)
 	}
@@ -170,6 +181,10 @@ func collectErrors(modules map[string]*runningModule) error {
 	for _, module := range modules {
 		if module.Err != nil {
 			errs = append(errs, module.Err)
+			fmt.Printf("----- ERRROR TYPE %T ----- \n", module.Err)
+			if _, isDepErr := module.Err.(DependencyFinishedWithError); !isDepErr {
+				module.ErrorChan <- map[string]error{module.Module.Path: fmt.Errorf("%s", module.OutStream.String())}
+			}
 		}
 	}
 
@@ -223,8 +238,11 @@ func (module *runningModule) runNow() error {
 		module.Module.TerragruntOptions.Logger.Printf("Running module %s now", module.Module.Path)
 		return module.Module.TerragruntOptions.RunTerragrunt(module.Module.TerragruntOptions)
 	}
+
 }
 
+var separator = strings.Repeat("-", 132)
+
 // Record that a module has finished executing and notify all of this module's dependencies
 func (module *runningModule) moduleFinished(moduleErr error) {
 	if moduleErr == nil {
@@ -233,6 +251,8 @@ func (module *runningModule) moduleFinished(moduleErr error) {
 		module.Module.TerragruntOptions.Logger.Printf("Module %s has finished with an error: %v", module.Module.Path, moduleErr)
 	}
 
+	fmt.Fprintf(module.Writer, "%s\n%v\n\n%v\n", separator, module.Module.Path, module.OutStream.String())
+
 	module.Status = Finished
 	module.Err = moduleErr
 

configstack/stack.go

@@ -5,18 +5,21 @@ import (
 	"fmt"
 	"strings"
 
+	"sort"
+
 	"github.com/gruntwork-io/terragrunt/config"
 	"github.com/gruntwork-io/terragrunt/errors"
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/util"
-	"sort"
 )
 
 // Represents a stack of Terraform modules (i.e. folders with Terraform templates) that you can "spin up" or
 // "spin down" in a single command
 type Stack struct {
-	Path    string
-	Modules []*TerraformModule
+	Path      string
+	Modules   []*TerraformModule
+	ErrorMap  map[string][]error
+	ErrorChan chan map[string]error
 }
 
 // Render this stack as a human-readable string
@@ -113,11 +116,25 @@ func FindStackInSubfolders(terragruntOptions *options.TerragruntOptions) (*Stack
 // Set the command in the TerragruntOptions object of each module in this stack to the given command.
 func (stack *Stack) setTerraformCommand(command []string) {
 	for _, module := range stack.Modules {
+		module.ErrorChan = stack.ErrorChan
 		module.TerragruntOptions.TerraformCliArgs = append(command, module.TerragruntOptions.TerraformCliArgs...)
 		module.TerragruntOptions.TerraformCommand = util.FirstArg(command)
 	}
 }
 
+func (stack *Stack) SetupErrorChannel() {
+	stack.ErrorMap = make(map[string][]error)
+	stack.ErrorChan = make(chan map[string]error)
+}
+
+func (stack *Stack) CollectModuleErrors() {
+	for errorMap := range stack.ErrorChan {
+		for module, err := range errorMap {
+			stack.ErrorMap[module] = append(stack.ErrorMap[module], err)
+		}
+	}
+}
+
 // Find all the Terraform modules in the folders that contain the given Terragrunt config files and assemble those
 // modules into a Stack object that can be applied or destroyed in a single command
 func createStackForTerragruntConfigPaths(path string, terragruntConfigPaths []string, terragruntOptions *options.TerragruntOptions, howThesePathsWereFound string) (*Stack, error) {

shell/run_shell_cmd.go

@@ -28,6 +28,12 @@ func RunShellCommand(terragruntOptions *options.TerragruntOptions, command strin
 	return err
 }
 
+func RunTerraformCommandAndRedirectOutputToLogger(terragruntOptions *options.TerragruntOptions, args ...string) error {
+	output, err := RunShellCommandWithOutput(terragruntOptions, "", terragruntOptions.TerraformPath, args...)
+	terragruntOptions.Logger.Println(output)
+	return err
+}
+
 // Run the given Terraform command, writing its stdout/stderr to the terminal AND returning stdout/stderr to this
 // method's caller
 func RunTerraformCommandWithOutput(terragruntOptions *options.TerragruntOptions, args ...string) (*CmdOutput, error) {