138 lines
3.5 KiB
Go
138 lines
3.5 KiB
Go
package command
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/terraform/terraform"
|
|
)
|
|
|
|
// RefreshCommand is a cli.Command implementation that refreshes the state
|
|
// file.
|
|
type RefreshCommand struct {
|
|
Meta
|
|
}
|
|
|
|
func (c *RefreshCommand) Run(args []string) int {
|
|
var statePath, stateOutPath string
|
|
|
|
args = c.Meta.process(args)
|
|
|
|
cmdFlags := flag.NewFlagSet("refresh", flag.ContinueOnError)
|
|
cmdFlags.StringVar(&statePath, "state", DefaultStateFilename, "path")
|
|
cmdFlags.StringVar(&stateOutPath, "state-out", "", "path")
|
|
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
|
|
if err := cmdFlags.Parse(args); err != nil {
|
|
return 1
|
|
}
|
|
|
|
var configPath string
|
|
args = cmdFlags.Args()
|
|
if len(args) > 1 {
|
|
c.Ui.Error("The apply command expacts at most one argument.")
|
|
cmdFlags.Usage()
|
|
return 1
|
|
} else if len(args) == 1 {
|
|
configPath = args[0]
|
|
} else {
|
|
var err error
|
|
configPath, err = os.Getwd()
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error getting pwd: %s", err))
|
|
}
|
|
}
|
|
|
|
// If we don't specify an output path, default to out normal state
|
|
// path.
|
|
if stateOutPath == "" {
|
|
stateOutPath = statePath
|
|
}
|
|
|
|
// Verify that the state path exists. The "ContextArg" function below
|
|
// will actually do this, but we want to provide a richer error message
|
|
// if possible.
|
|
if _, err := os.Stat(statePath); err != nil {
|
|
if os.IsNotExist(err) {
|
|
c.Ui.Error(fmt.Sprintf(
|
|
"The Terraform state file for your infrastructure does not\n"+
|
|
"exist. The 'refresh' command only works and only makes sense\n"+
|
|
"when there is existing state that Terraform is managing. Please\n"+
|
|
"double-check the value given below and try again. If you\n"+
|
|
"haven't created infrastructure with Terraform yet, use the\n"+
|
|
"'terraform apply' command.\n\n"+
|
|
"Path: %s",
|
|
statePath))
|
|
return 1
|
|
}
|
|
|
|
c.Ui.Error(fmt.Sprintf(
|
|
"There was an error reading the Terraform state that is needed\n"+
|
|
"for refreshing. The path and error are shown below.\n\n"+
|
|
"Path: %s\n\nError: %s",
|
|
statePath,
|
|
err))
|
|
return 1
|
|
}
|
|
|
|
// Build the context based on the arguments given
|
|
ctx, err := c.Context(configPath, statePath, false)
|
|
if err != nil {
|
|
c.Ui.Error(err.Error())
|
|
return 1
|
|
}
|
|
if !validateContext(ctx, c.Ui) {
|
|
return 1
|
|
}
|
|
|
|
state, err := ctx.Refresh()
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error refreshing state: %s", err))
|
|
return 1
|
|
}
|
|
|
|
log.Printf("[INFO] Writing state output to: %s", stateOutPath)
|
|
f, err := os.Create(stateOutPath)
|
|
if err == nil {
|
|
defer f.Close()
|
|
err = terraform.WriteState(state, f)
|
|
}
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error writing state file: %s", err))
|
|
return 1
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
func (c *RefreshCommand) Help() string {
|
|
helpText := `
|
|
Usage: terraform refresh [options] [dir]
|
|
|
|
Update the state file of your infrastructure with metadata that matches
|
|
the physical resources they are tracking.
|
|
|
|
This will not modify your infrastructure, but it can modify your
|
|
state file to update metadata. This metadata might cause new changes
|
|
to occur when you generate a plan or call apply next.
|
|
|
|
Options:
|
|
|
|
-no-color If specified, output won't contain any color.
|
|
|
|
-state=path Path to read and save state (unless state-out
|
|
is specified). Defaults to "terraform.tfstate".
|
|
|
|
-state-out=path Path to write updated state file. By default, the
|
|
"-state" path will be used.
|
|
|
|
`
|
|
return strings.TrimSpace(helpText)
|
|
}
|
|
|
|
func (c *RefreshCommand) Synopsis() string {
|
|
return "Update local state file against real resources"
|
|
}
|