terraform/command/output.go

348 lines
8.9 KiB
Go
Raw Normal View History

2014-07-13 19:25:42 +02:00
package command
import (
"bytes"
"encoding/json"
2014-07-13 19:25:42 +02:00
"fmt"
"sort"
2014-07-13 19:25:42 +02:00
"strings"
ctyjson "github.com/zclconf/go-cty/cty/json"
terraform: ugly huge change to weave in new HCL2-oriented types Due to how deeply the configuration types go into Terraform Core, there isn't a great way to switch out to HCL2 gradually. As a consequence, this huge commit gets us from the old state to a _compilable_ new state, but does not yet attempt to fix any tests and has a number of known missing parts and bugs. We will continue to iterate on this in forthcoming commits, heading back towards passing tests and making Terraform fully-functional again. The three main goals here are: - Use the configuration models from the "configs" package instead of the older models in the "config" package, which is now deprecated and preserved only to help us write our migration tool. - Do expression inspection and evaluation using the functionality of the new "lang" package, instead of the Interpolator type and related functionality in the main "terraform" package. - Represent addresses of various objects using types in the addrs package, rather than hand-constructed strings. This is not critical to support the above, but was a big help during the implementation of these other points since it made it much more explicit what kind of address is expected in each context. Since our new packages are built to accommodate some future planned features that are not yet implemented (e.g. the "for_each" argument on resources, "count"/"for_each" on modules), and since there's still a fair amount of functionality still using old-style APIs, there is a moderate amount of shimming here to connect new assumptions with old, hopefully in a way that makes it easier to find and eliminate these shims later. I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-04-30 19:33:53 +02:00
"github.com/hashicorp/terraform/addrs"
2019-08-07 01:58:58 +02:00
"github.com/hashicorp/terraform/configs/hcl2shim"
"github.com/hashicorp/terraform/repl"
"github.com/hashicorp/terraform/states"
"github.com/hashicorp/terraform/tfdiags"
2014-07-13 19:25:42 +02:00
)
// OutputCommand is a Command implementation that reads an output
// from a Terraform state and prints it.
type OutputCommand struct {
Meta
}
func (c *OutputCommand) Run(args []string) int {
args, err := c.Meta.process(args, false)
if err != nil {
return 1
}
2014-07-13 19:25:42 +02:00
var module, statePath string
var jsonOutput bool
cmdFlags := c.Meta.defaultFlagSet("output")
cmdFlags.BoolVar(&jsonOutput, "json", false, "json")
cmdFlags.StringVar(&statePath, "state", "", "path")
2015-05-27 16:46:12 +02:00
cmdFlags.StringVar(&module, "module", "", "module")
2014-07-13 19:25:42 +02:00
cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
if err := cmdFlags.Parse(args); err != nil {
return 1
}
args = cmdFlags.Args()
if len(args) > 1 {
2014-07-13 19:25:42 +02:00
c.Ui.Error(
"The output command expects exactly one argument with the name\n" +
"of an output variable or no arguments to show all outputs.\n")
2014-07-13 19:25:42 +02:00
cmdFlags.Usage()
return 1
}
name := ""
if len(args) > 0 {
name = args[0]
}
2014-07-13 19:25:42 +02:00
if statePath != "" {
c.Meta.statePath = statePath
}
var diags tfdiags.Diagnostics
2017-01-19 05:50:45 +01:00
// Load the backend
b, backendDiags := c.Backend(nil)
diags = diags.Append(backendDiags)
if backendDiags.HasErrors() {
c.showDiagnostics(diags)
2017-01-19 05:50:45 +01:00
return 1
}
env := c.Workspace()
2017-01-19 05:50:45 +01:00
// Get the state
stateStore, err := b.StateMgr(env)
2014-07-13 19:25:42 +02:00
if err != nil {
2017-01-19 05:50:45 +01:00
c.Ui.Error(fmt.Sprintf("Failed to load state: %s", err))
2014-07-13 19:25:42 +02:00
return 1
}
2017-02-17 03:44:43 +01:00
if err := stateStore.RefreshState(); err != nil {
c.Ui.Error(fmt.Sprintf("Failed to load state: %s", err))
return 1
}
moduleAddr := addrs.RootModuleInstance
if module != "" {
// This option was supported prior to 0.12.0, but no longer supported
// because we only persist the root module outputs in state.
// (We could perhaps re-introduce this by doing an eval walk here to
// repopulate them, similar to how "terraform console" does it, but
// that requires more thought since it would imply this command
// supporting remote operations, which is a big change.)
diags = diags.Append(tfdiags.Sourceless(
tfdiags.Error,
"Unsupported option",
"The -module option is no longer supported since Terraform 0.12, because now only root outputs are persisted in the state.",
))
c.showDiagnostics(diags)
return 1
}
2015-05-27 16:46:12 +02:00
state := stateStore.State()
if state == nil {
state = states.NewState()
}
mod := state.Module(moduleAddr)
2015-05-27 16:46:12 +02:00
if mod == nil {
c.Ui.Error(fmt.Sprintf(
2015-06-03 16:24:20 +02:00
"The module %s could not be found. There is nothing to output.",
2015-05-27 16:46:12 +02:00
module))
return 1
}
if !jsonOutput && (state.Empty() || len(mod.OutputValues) == 0) {
c.Ui.Error(
"The state file either has no outputs defined, or all the defined\n" +
"outputs are empty. Please define an output in your configuration\n" +
"with the `output` keyword and run `terraform refresh` for it to\n" +
"become available. If you are using interpolation, please verify\n" +
"the interpolated value is not empty. You can use the \n" +
"`terraform console` command to assist.")
2014-07-13 19:25:42 +02:00
return 1
}
2015-05-27 16:46:12 +02:00
if name == "" {
if jsonOutput {
// Due to a historical accident, the switch from state version 2 to
// 3 caused our JSON output here to be the full metadata about the
// outputs rather than just the output values themselves as we'd
// show in the single value case. We must now maintain that behavior
// for compatibility, so this is an emulation of the JSON
// serialization of outputs used in state format version 3.
type OutputMeta struct {
Sensitive bool `json:"sensitive"`
Type json.RawMessage `json:"type"`
Value json.RawMessage `json:"value"`
}
outputs := map[string]OutputMeta{}
for n, os := range mod.OutputValues {
jsonVal, err := ctyjson.Marshal(os.Value, os.Value.Type())
if err != nil {
diags = diags.Append(err)
c.showDiagnostics(diags)
return 1
}
jsonType, err := ctyjson.MarshalType(os.Value.Type())
if err != nil {
diags = diags.Append(err)
c.showDiagnostics(diags)
return 1
}
outputs[n] = OutputMeta{
Sensitive: os.Sensitive,
Type: json.RawMessage(jsonType),
Value: json.RawMessage(jsonVal),
}
}
jsonOutputs, err := json.MarshalIndent(outputs, "", " ")
if err != nil {
diags = diags.Append(err)
c.showDiagnostics(diags)
return 1
}
c.Ui.Output(string(jsonOutputs))
return 0
} else {
c.Ui.Output(outputsAsString(state, moduleAddr, false))
return 0
}
}
os, ok := mod.OutputValues[name]
2014-07-13 19:25:42 +02:00
if !ok {
c.Ui.Error(fmt.Sprintf(
"The output variable requested could not be found in the state\n" +
"file. If you recently added this to your configuration, be\n" +
"sure to run `terraform apply`, since the state won't be updated\n" +
"with new output variables until that command is run."))
return 1
}
v := os.Value
2014-07-13 19:25:42 +02:00
if jsonOutput {
jsonOutput, err := ctyjson.Marshal(v, v.Type())
if err != nil {
return 1
}
c.Ui.Output(string(jsonOutput))
} else {
// Our formatter still wants an old-style raw interface{} value, so
// for now we'll just shim it.
// FIXME: Port the formatter to work with cty.Value directly.
legacyVal := hcl2shim.ConfigValueFromHCL2(v)
result, err := repl.FormatResult(legacyVal)
if err != nil {
diags = diags.Append(err)
c.showDiagnostics(diags)
return 1
}
c.Ui.Output(result)
}
2014-07-13 19:25:42 +02:00
return 0
}
func formatNestedList(indent string, outputList []interface{}) string {
outputBuf := new(bytes.Buffer)
outputBuf.WriteString(fmt.Sprintf("%s[", indent))
lastIdx := len(outputList) - 1
for i, value := range outputList {
outputBuf.WriteString(fmt.Sprintf("\n%s%s%s", indent, " ", value))
if i != lastIdx {
outputBuf.WriteString(",")
}
}
outputBuf.WriteString(fmt.Sprintf("\n%s]", indent))
return strings.TrimPrefix(outputBuf.String(), "\n")
}
func formatListOutput(indent, outputName string, outputList []interface{}) string {
keyIndent := ""
outputBuf := new(bytes.Buffer)
if outputName != "" {
outputBuf.WriteString(fmt.Sprintf("%s%s = [", indent, outputName))
keyIndent = " "
}
lastIdx := len(outputList) - 1
for i, value := range outputList {
switch typedValue := value.(type) {
case string:
outputBuf.WriteString(fmt.Sprintf("\n%s%s%s", indent, keyIndent, value))
case []interface{}:
outputBuf.WriteString(fmt.Sprintf("\n%s%s", indent,
formatNestedList(indent+keyIndent, typedValue)))
case map[string]interface{}:
outputBuf.WriteString(fmt.Sprintf("\n%s%s", indent,
formatNestedMap(indent+keyIndent, typedValue)))
}
if lastIdx != i {
outputBuf.WriteString(",")
}
}
if outputName != "" {
if len(outputList) > 0 {
outputBuf.WriteString(fmt.Sprintf("\n%s]", indent))
} else {
outputBuf.WriteString("]")
}
}
return strings.TrimPrefix(outputBuf.String(), "\n")
}
func formatNestedMap(indent string, outputMap map[string]interface{}) string {
ks := make([]string, 0, len(outputMap))
for k, _ := range outputMap {
ks = append(ks, k)
}
sort.Strings(ks)
outputBuf := new(bytes.Buffer)
outputBuf.WriteString(fmt.Sprintf("%s{", indent))
lastIdx := len(outputMap) - 1
for i, k := range ks {
v := outputMap[k]
outputBuf.WriteString(fmt.Sprintf("\n%s%s = %v", indent+" ", k, v))
if lastIdx != i {
outputBuf.WriteString(",")
}
}
outputBuf.WriteString(fmt.Sprintf("\n%s}", indent))
return strings.TrimPrefix(outputBuf.String(), "\n")
}
2017-01-19 05:50:45 +01:00
func formatMapOutput(indent, outputName string, outputMap map[string]interface{}) string {
ks := make([]string, 0, len(outputMap))
for k, _ := range outputMap {
ks = append(ks, k)
}
sort.Strings(ks)
keyIndent := ""
outputBuf := new(bytes.Buffer)
if outputName != "" {
outputBuf.WriteString(fmt.Sprintf("%s%s = {", indent, outputName))
keyIndent = " "
}
for _, k := range ks {
v := outputMap[k]
outputBuf.WriteString(fmt.Sprintf("\n%s%s%s = %v", indent, keyIndent, k, v))
}
if outputName != "" {
if len(outputMap) > 0 {
outputBuf.WriteString(fmt.Sprintf("\n%s}", indent))
} else {
outputBuf.WriteString("}")
}
}
return strings.TrimPrefix(outputBuf.String(), "\n")
}
2014-07-13 19:25:42 +02:00
func (c *OutputCommand) Help() string {
helpText := `
Usage: terraform output [options] [NAME]
2014-07-13 19:25:42 +02:00
Reads an output variable from a Terraform state file and prints
the value. With no additional arguments, output will display all
the outputs for the root module. If NAME is not specified, all
outputs are printed.
2014-07-13 19:25:42 +02:00
Options:
-state=path Path to the state file to read. Defaults to
"terraform.tfstate".
-no-color If specified, output won't contain any color.
2014-07-13 19:25:42 +02:00
-json If specified, machine readable output will be
printed in JSON format
2014-07-13 19:25:42 +02:00
`
return strings.TrimSpace(helpText)
}
func (c *OutputCommand) Synopsis() string {
return "Read an output from a state file"
}