Merge pull request #149 from fajpunk/output-all

Output all

Author: brikis98

README.md

@@ -362,7 +362,7 @@ The solution is to use the following features of Terragrunt:
 * Find parent helper
 * Relative path helper
 * Overriding included settings
-* The `spin-up` and `tear-down` commands
+* The `apply-all`, `destroy-all`, and `output-all` commands
 * Dependencies between modules
 
 ### Includes
@@ -646,7 +646,7 @@ terragrunt= {
   }
 ```
 
-### The spin-up and tear-down commands
+### The apply-all, destroy-all, and output-all commands
 
 Let's say you have a single environment (e.g. `stage` or `prod`) that has a number of Terraform modules within it:
 
@@ -678,21 +678,28 @@ There is one module to deploy a frontend-app, another to deploy a backend-app, a
 on. To deploy such an environment, you'd have to manually run `terragrunt apply` in each of the subfolders. How do you
 avoid this tedious and time-consuming process?
 
-The answer is that you can use the `spin-up` command:
+The answer is that you can use the `apply-all` command:
 
 ```
 cd my-terraform-repo/stage
-terragrunt spin-up
+terragrunt apply-all
 ```
 
 When you run this command, Terragrunt will find all `terraform.tfvars` files in the subfolders of the current working 
-directory that contain `terragrunt = { ... }` blocks, and run `terragrunt apply` in each one concurrently.  
+directory that contain `terragrunt = { ... }` blocks, and run `terragrunt apply` in each one concurrently.
 
-Similarly, to undeploy all the Terraform modules, you can use the `tear-down` command:
+Similarly, to undeploy all the Terraform modules, you can use the `destroy-all` command:
 
 ```
 cd my-terraform-repo/stage
-terragrunt tear-down
+terragrunt destroy-all
+```
+
+Finally, to see the currently applied outputs of all of the subfolders, you can use the `output-all` command:
+
+```
+cd my-terraform-repo/stage
+terragrunt output-all
 ```
 
 Of course, if your modules have dependencies between them—for example, you can't deploy the backend-app until the MySQL
@@ -762,17 +769,17 @@ terragrunt = {
 }
 ```
 
-Once you've specified the depenedencies in each `terraform.tfvars` file, when you run the `terragrunt spin-up` and 
-`terragrunt tear-down`, Terragrunt will ensure that the dependencies are applied or destroyed, respectively, in the
-correct order. For the example at the start of this section, the order for the `spin-up` command would be:
+Once you've specified the depenedencies in each `terraform.tfvars` file, when you run the `terragrunt apply-all` and 
+`terragrunt destroy-all`, Terragrunt will ensure that the dependencies are applied or destroyed, respectively, in the
+correct order. For the example at the start of this section, the order for the `apply-all` command would be:
 
 1. Deploy the VPC
 1. Deploy MySQL and Redis in parallel
 1. Deploy the backend-app
 1. Deploy the frontend-app and search-app in parallel
 
 If any of the modules fail to deploy, then Terragrunt will not attempt to deploy the modules that depend on them. Once
-you've fixed the error, it's usually safe to re-run the `spin-up` or `tear-down` command again, since it'll be a noop
+you've fixed the error, it's usually safe to re-run the `apply-all` or `destroy-all` command again, since it'll be a noop
 for the modules that already deployed successfully, and should only affect the ones that had an error the last time
 around.
 
@@ -939,7 +946,7 @@ prefix `--terragrunt-`. The currently available options are:
 * `--terragrunt-non-interactive`: Don't show interactive user prompts. This will default the answer for all prompts to 
   'yes'. Useful if you need to run Terragrunt in an automated setting (e.g. from a script).  
 * `--terragrunt-working-dir`: Set the directory where Terragrunt should execute the `terraform` command. Default is the
-  current working directory. Note that for the `spin-up` and `tear-down` directories, this parameter has a different 
+  current working directory. Note that for the `apply-all` and `destroy-all` directories, this parameter has a different 
   meaning: Terragrunt will apply or destroy all the Terraform modules in the subfolders of the 
   `terragrunt-working-dir`, running `terraform` in the root of each module it finds.
 * `--terragrunt-source`: Download Terraform configurations from the specified source into a temporary folder, and run 

cli/args.go

@@ -14,7 +14,15 @@ import (
 
 // Parse command line options that are passed in for Terragrunt
 func ParseTerragruntOptions(cliContext *cli.Context) (*options.TerragruntOptions, error) {
-	return parseTerragruntOptionsFromArgs(cliContext.Args())
+	terragruntOptions, err := parseTerragruntOptionsFromArgs(cliContext.Args())
+	if err != nil {
+		return nil, err
+	}
+
+	terragruntOptions.Writer = cliContext.App.Writer
+	terragruntOptions.ErrWriter = cliContext.App.ErrWriter
+
+	return terragruntOptions, nil
 }
 
 // TODO: replace the urfave CLI library with something else.

cli/args_test.go

@@ -153,8 +153,8 @@ func TestFilterTerragruntArgs(t *testing.T) {
 		{[]string{"foo", "--terragrunt-config", fmt.Sprintf("/some/path/%s", config.DefaultTerragruntConfigPath)}, []string{"foo"}},
 		{[]string{"foo", "--terragrunt-non-interactive"}, []string{"foo"}},
 		{[]string{"foo", "--terragrunt-non-interactive", "--bar", "--terragrunt-working-dir", "/some/path", "--baz", "--terragrunt-config", fmt.Sprintf("/some/path/%s", config.DefaultTerragruntConfigPath)}, []string{"foo", "--bar", "--baz"}},
-		{[]string{"spin-up", "foo", "bar"}, []string{"foo", "bar"}},
-		{[]string{"foo", "tear-down", "--foo", "--bar"}, []string{"foo", "--foo", "--bar"}},
+		{[]string{"apply-all", "foo", "bar"}, []string{"foo", "bar"}},
+		{[]string{"foo", "destroy-all", "--foo", "--bar"}, []string{"foo", "--foo", "--bar"}},
 	}
 
 	for _, testCase := range testCases {

cli/cli_app.go

@@ -5,14 +5,15 @@ import (
 	"regexp"
 
 	"github.com/gruntwork-io/terragrunt/config"
+	"github.com/gruntwork-io/terragrunt/configstack"
 	"github.com/gruntwork-io/terragrunt/errors"
 	"github.com/gruntwork-io/terragrunt/locks"
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/remote"
 	"github.com/gruntwork-io/terragrunt/shell"
-	"github.com/gruntwork-io/terragrunt/spin"
 	"github.com/gruntwork-io/terragrunt/util"
 	"github.com/urfave/cli"
+	"io"
 )
 
 const OPT_TERRAGRUNT_CONFIG = "terragrunt-config"
@@ -27,10 +28,24 @@ var ALL_TERRAGRUNT_STRING_OPTS = []string{OPT_TERRAGRUNT_CONFIG, OPT_TERRAGRUNT_
 
 const CMD_ACQUIRE_LOCK = "acquire-lock"
 const CMD_RELEASE_LOCK = "release-lock"
+
+const CMD_APPLY_ALL = "apply-all"
+const CMD_DESTROY_ALL = "destroy-all"
+const CMD_OUTPUT_ALL = "output-all"
+
+// CMD_SPIN_UP is deprecated.
 const CMD_SPIN_UP = "spin-up"
+
+// CMD_TEAR_DOWN is deprecated.
 const CMD_TEAR_DOWN = "tear-down"
 
-var MULTI_MODULE_COMMANDS = []string{CMD_SPIN_UP, CMD_TEAR_DOWN}
+var MULTI_MODULE_COMMANDS = []string{CMD_APPLY_ALL, CMD_DESTROY_ALL, CMD_OUTPUT_ALL}
+
+// DEPRECATED_COMMANDS is a map of deprecated commands to the commands that replace them.
+var DEPRECATED_COMMANDS = map[string]string{
+	CMD_SPIN_UP:   CMD_APPLY_ALL,
+	CMD_TEAR_DOWN: CMD_DESTROY_ALL,
+}
 
 // Since Terragrunt is just a thin wrapper for Terraform, and we don't want to repeat every single Terraform command
 // in its definition, we don't quite fit into the model of any Go CLI library. Fortunately, urfave/cli allows us to
@@ -53,8 +68,9 @@ COMMANDS:
    remote push          Acquire a lock and run 'terraform remote push'
    acquire-lock         Acquire a long-term lock for these templates
    release-lock         Release a long-term lock or a lock that failed to clean up
-   spin-up              Spin up a 'stack' by running 'terragrunt apply' in each subfolder
-   tear-down            Tear down a 'stack' by running 'terragrunt destroy' in each subfolder
+   apply-all            Apply a 'stack' by running 'terragrunt apply' in each subfolder
+   output-all           Display the outputs of a 'stack' by running 'terragrunt output' in each subfolder
+   destroy-all          Destroy a 'stack' by running 'terragrunt destroy' in each subfolder
    *                    Terragrunt forwards all other commands directly to Terraform
 
 GLOBAL OPTIONS:
@@ -78,7 +94,7 @@ var MODULE_REGEX = regexp.MustCompile(`module ".+"`)
 const TERRAFORM_EXTENSION_GLOB = "*.tf"
 
 // Create the Terragrunt CLI App
-func CreateTerragruntCli(version string) *cli.App {
+func CreateTerragruntCli(version string, writer io.Writer, errwriter io.Writer) *cli.App {
 	cli.OsExiter = func(exitCode int) {
 		// Do nothing. We just need to override this function, as the default value calls os.Exit, which
 		// kills the app (or any automated test) dead in its tracks.
@@ -93,6 +109,8 @@ func CreateTerragruntCli(version string) *cli.App {
 	app.Version = version
 	app.Action = runApp
 	app.Usage = "terragrunt <COMMAND>"
+	app.Writer = writer
+	app.ErrWriter = errwriter
 	app.UsageText = fmt.Sprintf(`Terragrunt is a thin wrapper for [Terraform](https://www.terraform.io/) that supports locking
    via Amazon's DynamoDB and enforces best practices. Terragrunt forwards almost all commands, arguments, and options
    directly to Terraform, using whatever version of Terraform you already have installed. However, before running
@@ -119,11 +137,28 @@ func runApp(cliContext *cli.Context) (finalErr error) {
 		return err
 	}
 
-	if isMultiModuleCommand(cliContext.Args().First()) {
-		return runMultiModuleCommand(cliContext.Args().First(), terragruntOptions)
-	} else {
-		return runTerragrunt(terragruntOptions)
+	givenCommand := cliContext.Args().First()
+	command := checkDeprecated(givenCommand)
+	return runCommand(command, terragruntOptions)
+}
+
+// checkDeprecated checks if the given command is deprecated.  If so: prints a message and returns the new command.
+func checkDeprecated(command string) string {
+	newCommand, deprecated := DEPRECATED_COMMANDS[command]
+	if deprecated {
+		fmt.Printf("%v is deprecated; running %v instead.\n", command, newCommand)
+		return newCommand
+	}
+	return command
+}
+
+// runCommand runs one or many terraform commands based on the type of
+// terragrunt command
+func runCommand(command string, terragruntOptions *options.TerragruntOptions) (finalEff error) {
+	if isMultiModuleCommand(command) {
+		return runMultiModuleCommand(command, terragruntOptions)
 	}
+	return runTerragrunt(terragruntOptions)
 }
 
 // Run Terragrunt with the given options and CLI args. This will forward all the args directly to Terraform, enforcing
@@ -163,18 +198,20 @@ func runTerragrunt(terragruntOptions *options.TerragruntOptions) error {
 }
 
 // Returns true if the command the user wants to execute is supposed to affect multiple Terraform modules, such as the
-// spin-up or tear-down command.
+// apply-all or destroy-all command.
 func isMultiModuleCommand(command string) bool {
 	return util.ListContainsElement(MULTI_MODULE_COMMANDS, command)
 }
 
-// Execute a command that affects multiple Terraform modules, such as the spin-up or tear-down command.
+// Execute a command that affects multiple Terraform modules, such as the apply-all or destroy-all command.
 func runMultiModuleCommand(command string, terragruntOptions *options.TerragruntOptions) error {
 	switch command {
-	case CMD_SPIN_UP:
-		return spinUp(terragruntOptions)
-	case CMD_TEAR_DOWN:
-		return tearDown(terragruntOptions)
+	case CMD_APPLY_ALL:
+		return applyAll(terragruntOptions)
+	case CMD_DESTROY_ALL:
+		return destroyAll(terragruntOptions)
+	case CMD_OUTPUT_ALL:
+		return outputAll(terragruntOptions)
 	default:
 		return errors.WithStackTrace(UnrecognizedCommand(command))
 	}
@@ -253,19 +290,19 @@ func runTerraformCommandWithLock(lock locks.Lock, terragruntOptions *options.Ter
 
 // Spin up an entire "stack" by running 'terragrunt apply' in each subfolder, processing them in the right order based
 // on terraform_remote_state dependencies.
-func spinUp(terragruntOptions *options.TerragruntOptions) error {
-	stack, err := spin.FindStackInSubfolders(terragruntOptions)
+func applyAll(terragruntOptions *options.TerragruntOptions) error {
+	stack, err := configstack.FindStackInSubfolders(terragruntOptions)
 	if err != nil {
 		return err
 	}
 
 	terragruntOptions.Logger.Printf("%s", stack.String())
-	shouldSpinUp, err := shell.PromptUserForYesNo("Are you sure you want to run 'terragrunt apply' in each folder of the stack described above?", terragruntOptions)
+	shouldApplyAll, err := shell.PromptUserForYesNo("Are you sure you want to run 'terragrunt apply' in each folder of the stack described above?", terragruntOptions)
 	if err != nil {
 		return err
 	}
 
-	if shouldSpinUp {
+	if shouldApplyAll {
 		return stack.Apply(terragruntOptions)
 	}
 
@@ -274,25 +311,37 @@ func spinUp(terragruntOptions *options.TerragruntOptions) error {
 
 // Tear down an entire "stack" by running 'terragrunt destroy' in each subfolder, processing them in the right order
 // based on terraform_remote_state dependencies.
-func tearDown(terragruntOptions *options.TerragruntOptions) error {
-	stack, err := spin.FindStackInSubfolders(terragruntOptions)
+func destroyAll(terragruntOptions *options.TerragruntOptions) error {
+	stack, err := configstack.FindStackInSubfolders(terragruntOptions)
 	if err != nil {
 		return err
 	}
 
 	terragruntOptions.Logger.Printf("%s", stack.String())
-	shouldTearDown, err := shell.PromptUserForYesNo("WARNING: Are you sure you want to run `terragrunt destroy` in each folder of the stack described above? There is no undo!", terragruntOptions)
+	shouldDestroyAll, err := shell.PromptUserForYesNo("WARNING: Are you sure you want to run `terragrunt destroy` in each folder of the stack described above? There is no undo!", terragruntOptions)
 	if err != nil {
 		return err
 	}
 
-	if shouldTearDown {
+	if shouldDestroyAll {
 		return stack.Destroy(terragruntOptions)
 	}
 
 	return nil
 }
 
+// outputAll prints the outputs from all configuration in a stack, in the order
+// specified in the terraform_remote_state dependencies
+func outputAll(terragruntOptions *options.TerragruntOptions) error {
+	stack, err := configstack.FindStackInSubfolders(terragruntOptions)
+	if err != nil {
+		return err
+	}
+
+	terragruntOptions.Logger.Printf("%s", stack.String())
+	return stack.Output(terragruntOptions)
+}
+
 // Acquire a lock. This can be useful for locking down a deploy for a long time, such as during a major deployment.
 func acquireLock(lock locks.Lock, terragruntOptions *options.TerragruntOptions) error {
 	shouldAcquireLock, err := shell.PromptUserForYesNo("Are you sure you want to acquire a long-term lock?", terragruntOptions)

spin/graph.go configstack/graph.gospin/graph.go renamed to configstack/graph.go

@@ -1,4 +1,4 @@
-package spin
+package configstack
 
 import (
 	"github.com/gruntwork-io/terragrunt/errors"

spin/graph_test.go configstack/graph_test.gospin/graph_test.go renamed to configstack/graph_test.go

@@ -1,4 +1,4 @@
-package spin
+package configstack
 
 import (
 	"github.com/gruntwork-io/terragrunt/errors"

spin/module.go configstack/module.gospin/module.go renamed to configstack/module.go

@@ -1,4 +1,4 @@
-package spin
+package configstack
 
 import (
 	"fmt"
@@ -89,7 +89,7 @@ func resolveTerraformModule(terragruntConfigPath string, terragruntOptions *opti
 // Look through the dependencies of the modules in the given map and resolve the "external" dependency paths listed in
 // each modules config (i.e. those dependencies not in the given list of Terragrunt config canonical file paths).
 // These external dependencies are outside of the current working directory, which means they may not be part of the
-// environment the user is trying to spin-up or tear down. Therefore, this method also confirms whether the user wants
+// environment the user is trying to apply-all or destroy-all. Therefore, this method also confirms whether the user wants
 // to actually apply those dependencies or just assume they are already applied. Note that this method will NOT fill in
 // the Dependencies field of the TerraformModule struct (see the crosslinkDependencies method for that).
 func resolveExternalDependenciesForModules(canonicalTerragruntConfigPaths []string, moduleMap map[string]*TerraformModule, terragruntOptions *options.TerragruntOptions) (map[string]*TerraformModule, error) {
@@ -122,7 +122,7 @@ func resolveExternalDependenciesForModules(canonicalTerragruntConfigPaths []stri
 // Look through the dependencies of the given module and resolve the "external" dependency paths listed in the module's
 // config (i.e. those dependencies not in the given list of Terragrunt config canonical file paths). These external
 // dependencies are outside of the current working directory, which means they may not be part of the environment the
-// user is trying to spin-up or tear down. Note that this method will NOT fill in the Dependencies field of the
+// user is trying to apply-all or destroy-all. Note that this method will NOT fill in the Dependencies field of the
 // TerraformModule struct (see the crosslinkDependencies method for that).
 func resolveExternalDependenciesForModule(module *TerraformModule, canonicalTerragruntConfigPaths []string, terragruntOptions *options.TerragruntOptions) (map[string]*TerraformModule, error) {
 	if module.Config.Dependencies == nil || len(module.Config.Dependencies.Paths) == 0 {

spin/module_test.go configstack/module_test.gospin/module_test.go renamed to configstack/module_test.go

@@ -1,4 +1,4 @@
-package spin
+package configstack
 
 import (
 	"github.com/gruntwork-io/terragrunt/config"

spin/running_module.go configstack/running_module.gospin/running_module.go renamed to configstack/running_module.go

@@ -1,4 +1,4 @@
-package spin
+package configstack
 
 import (
 	"fmt"
@@ -7,7 +7,7 @@ import (
 	"sync"
 )
 
-// Represents the status of a module that we are trying to apply as part of the spin-up or tear-down command
+// Represents the status of a module that we are trying to apply as part of the apply-all or destroy-all command
 type ModuleStatus int
 
 const (
@@ -16,7 +16,7 @@ const (
 	Finished
 )
 
-// Represents a module we are trying to "run" (i.e. apply or destroy) as part of the spin-up or tear-down command
+// Represents a module we are trying to "run" (i.e. apply or destroy) as part of the apply-all or destroy-all command
 type runningModule struct {
 	Module         *TerraformModule
 	Status         ModuleStatus

spin/running_module_test.go configstack/running_module_test.gospin/running_module_test.go renamed to configstack/running_module_test.go

@@ -1,4 +1,4 @@
-package spin
+package configstack
 
 import (
 	"fmt"