terraform/command/format_state.go

153 lines
3.5 KiB
Go
Raw Normal View History

2014-07-13 04:47:31 +02:00
package command
import (
"bytes"
"fmt"
"sort"
"strings"
"github.com/hashicorp/terraform/terraform"
"github.com/mitchellh/colorstring"
)
// FormatStateOpts are the options for formatting a state.
type FormatStateOpts struct {
// State is the state to format. This is required.
State *terraform.State
// Color is the colorizer. This is optional.
Color *colorstring.Colorize
// ModuleDepth is the depth of the modules to expand. By default this
// is zero which will not expand modules at all.
ModuleDepth int
}
2014-07-13 04:47:31 +02:00
// FormatState takes a state and returns a string
func FormatState(opts *FormatStateOpts) string {
if opts.Color == nil {
panic("colorize not given")
2014-07-13 04:47:31 +02:00
}
s := opts.State
2014-09-17 20:15:07 +02:00
if len(s.Modules) == 0 {
return "The state file is empty. No resources are represented."
2014-07-13 04:47:31 +02:00
}
2014-09-17 20:15:07 +02:00
var buf bytes.Buffer
buf.WriteString("[reset]")
// Format all the modules
2014-09-17 20:15:07 +02:00
for _, m := range s.Modules {
if len(m.Path)-1 <= opts.ModuleDepth || opts.ModuleDepth == -1 {
formatStateModuleExpand(&buf, m, opts)
} else {
formatStateModuleSingle(&buf, m, opts)
}
2014-09-17 20:15:07 +02:00
}
// Write the outputs for the root module
m := s.RootModule()
if len(m.Outputs) > 0 {
buf.WriteString("\nOutputs:\n\n")
// Sort the outputs
ks := make([]string, 0, len(m.Outputs))
for k, _ := range m.Outputs {
ks = append(ks, k)
}
sort.Strings(ks)
// Output each output k/v pair
for _, k := range ks {
v := m.Outputs[k]
switch output := v.Value.(type) {
case string:
buf.WriteString(fmt.Sprintf("%s = %s", k, output))
buf.WriteString("\n")
case []interface{}:
buf.WriteString(formatListOutput("", k, output))
buf.WriteString("\n")
case map[string]interface{}:
buf.WriteString(formatMapOutput("", k, output))
buf.WriteString("\n")
}
}
}
return opts.Color.Color(strings.TrimSpace(buf.String()))
2014-09-17 20:15:07 +02:00
}
func formatStateModuleExpand(
buf *bytes.Buffer, m *terraform.ModuleState, opts *FormatStateOpts) {
var moduleName string
if !m.IsRoot() {
moduleName = fmt.Sprintf("module.%s", strings.Join(m.Path[1:], "."))
}
2014-07-13 04:47:31 +02:00
// First get the names of all the resources so we can show them
// in alphabetical order.
2014-09-17 20:15:07 +02:00
names := make([]string, 0, len(m.Resources))
for name, _ := range m.Resources {
2014-07-13 04:47:31 +02:00
names = append(names, name)
}
sort.Strings(names)
// Go through each resource and begin building up the output.
for _, k := range names {
name := k
if moduleName != "" {
name = moduleName + "." + name
}
2014-09-17 20:15:07 +02:00
rs := m.Resources[k]
is := rs.Primary
var id string
if is != nil {
id = is.ID
}
2014-07-13 04:47:31 +02:00
if id == "" {
id = "<not created>"
}
2014-07-22 21:36:32 +02:00
taintStr := ""
if rs.Primary.Tainted {
2014-09-17 20:15:07 +02:00
taintStr = " (tainted)"
2014-07-22 21:36:32 +02:00
}
buf.WriteString(fmt.Sprintf("%s:%s\n", name, taintStr))
2014-07-13 04:47:31 +02:00
buf.WriteString(fmt.Sprintf(" id = %s\n", id))
if is != nil {
// Sort the attributes
attrKeys := make([]string, 0, len(is.Attributes))
for ak, _ := range is.Attributes {
// Skip the id attribute since we just show the id directly
if ak == "id" {
continue
}
2014-07-13 04:47:31 +02:00
attrKeys = append(attrKeys, ak)
}
sort.Strings(attrKeys)
2014-07-13 04:47:31 +02:00
// Output each attribute
for _, ak := range attrKeys {
av := is.Attributes[ak]
buf.WriteString(fmt.Sprintf(" %s = %s\n", ak, av))
}
2014-07-13 04:47:31 +02:00
}
}
buf.WriteString("[reset]\n")
}
2014-07-13 04:47:31 +02:00
func formatStateModuleSingle(
buf *bytes.Buffer, m *terraform.ModuleState, opts *FormatStateOpts) {
// Header with the module name
buf.WriteString(fmt.Sprintf("module.%s\n", strings.Join(m.Path[1:], ".")))
2014-07-13 04:47:31 +02:00
// Now just write how many resources are in here.
buf.WriteString(fmt.Sprintf(" %d resource(s)\n", len(m.Resources)))
2014-07-13 04:47:31 +02:00
}