terraform/command/plan.go

143 lines
3.3 KiB
Go
Raw Normal View History

package command
import (
"flag"
"fmt"
2014-06-27 07:23:51 +02:00
"log"
2014-06-19 22:51:05 +02:00
"os"
"strings"
"github.com/hashicorp/terraform/config"
"github.com/hashicorp/terraform/terraform"
"github.com/mitchellh/cli"
)
2014-06-20 20:47:02 +02:00
// PlanCommand is a Command implementation that compares a Terraform
// configuration to an actual infrastructure and shows the differences.
2014-06-20 20:47:02 +02:00
type PlanCommand struct {
TFConfig *terraform.Config
Ui cli.Ui
}
2014-06-20 20:47:02 +02:00
func (c *PlanCommand) Run(args []string) int {
var destroy, refresh bool
2014-06-27 07:23:51 +02:00
var outPath, statePath string
2014-06-19 22:51:05 +02:00
2014-06-20 20:47:02 +02:00
cmdFlags := flag.NewFlagSet("plan", flag.ContinueOnError)
cmdFlags.BoolVar(&destroy, "destroy", false, "destroy")
2014-06-26 18:56:29 +02:00
cmdFlags.BoolVar(&refresh, "refresh", true, "refresh")
2014-06-27 07:23:51 +02:00
cmdFlags.StringVar(&outPath, "out", "", "path")
2014-06-19 22:51:05 +02:00
cmdFlags.StringVar(&statePath, "state", "", "path")
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
if err := cmdFlags.Parse(args); err != nil {
return 1
}
args = cmdFlags.Args()
if len(args) != 1 {
c.Ui.Error(
2014-06-20 20:47:02 +02:00
"The plan command expects only one argument with the path\n" +
"to a Terraform configuration.\n")
cmdFlags.Usage()
return 1
}
2014-06-19 22:51:05 +02:00
// Load up the state
var state *terraform.State
if statePath != "" {
f, err := os.Open(statePath)
if err != nil {
c.Ui.Error(fmt.Sprintf("Error loading state: %s", err))
return 1
}
state, err = terraform.ReadState(f)
f.Close()
if err != nil {
c.Ui.Error(fmt.Sprintf("Error loading state: %s", err))
return 1
}
}
b, err := config.Load(args[0])
if err != nil {
c.Ui.Error(fmt.Sprintf("Error loading blueprint: %s", err))
return 1
}
2014-06-27 02:17:10 +02:00
c.TFConfig.Hooks = append(c.TFConfig.Hooks, &UiHook{Ui: c.Ui})
2014-06-26 03:22:42 +02:00
tf, err := terraform.New(c.TFConfig)
if err != nil {
c.Ui.Error(fmt.Sprintf("Error initializing Terraform: %s", err))
return 1
}
2014-06-26 18:56:29 +02:00
if refresh {
state, err = tf.Refresh(b, state)
if err != nil {
c.Ui.Error(fmt.Sprintf("Error refreshing state: %s", err))
return 1
}
}
plan, err := tf.Plan(&terraform.PlanOpts{
Config: b,
Destroy: destroy,
State: state,
})
2014-06-10 20:34:08 +02:00
if err != nil {
2014-06-20 20:47:02 +02:00
c.Ui.Error(fmt.Sprintf("Error running plan: %s", err))
2014-06-10 20:34:08 +02:00
return 1
}
2014-06-20 20:47:02 +02:00
if plan.Diff.Empty() {
2014-06-19 23:58:30 +02:00
c.Ui.Output("No changes. Infrastructure is up-to-date.")
2014-06-27 07:23:51 +02:00
return 0
}
c.Ui.Output(strings.TrimSpace(plan.String()))
if outPath != "" {
log.Printf("[INFO] Writing plan output to: %s", outPath)
f, err := os.Create(outPath)
if err == nil {
defer f.Close()
err = terraform.WritePlan(plan, f)
}
if err != nil {
c.Ui.Error(fmt.Sprintf("Error writing plan file: %s", err))
return 1
}
2014-06-19 23:58:30 +02:00
}
2014-06-10 20:34:08 +02:00
return 0
}
2014-06-20 20:47:02 +02:00
func (c *PlanCommand) Help() string {
helpText := `
2014-06-20 20:47:02 +02:00
Usage: terraform plan [options] [terraform.tf]
Shows the differences between the Terraform configuration and
the actual state of an infrastructure.
Options:
2014-07-01 18:12:35 +02:00
-destroy If set, a plan will be generated to destroy all resources
managed by the given configuration and state.
2014-06-27 07:23:51 +02:00
-out=path Write a plan file to the given path. This can be used as
input to the "apply" command.
2014-06-26 18:56:29 +02:00
-refresh=true Update state prior to checking for differences.
-state=statefile Path to a Terraform state file to use to look
up Terraform-managed resources.
`
return strings.TrimSpace(helpText)
}
2014-06-20 20:47:02 +02:00
func (c *PlanCommand) Synopsis() string {
return "Show changes between Terraform config and infrastructure"
}