2018-12-19 20:08:25 +01:00
|
|
|
package jsonplan
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2019-01-12 00:13:55 +01:00
|
|
|
"sort"
|
2018-12-19 20:08:25 +01:00
|
|
|
|
|
|
|
"github.com/zclconf/go-cty/cty"
|
2019-01-25 18:17:40 +01:00
|
|
|
ctyjson "github.com/zclconf/go-cty/cty/json"
|
2018-12-19 20:08:25 +01:00
|
|
|
|
|
|
|
"github.com/hashicorp/terraform/addrs"
|
|
|
|
"github.com/hashicorp/terraform/command/jsonconfig"
|
|
|
|
"github.com/hashicorp/terraform/command/jsonstate"
|
|
|
|
"github.com/hashicorp/terraform/configs"
|
|
|
|
"github.com/hashicorp/terraform/plans"
|
|
|
|
"github.com/hashicorp/terraform/states"
|
2019-01-25 00:28:53 +01:00
|
|
|
"github.com/hashicorp/terraform/states/statefile"
|
2018-12-19 20:08:25 +01:00
|
|
|
"github.com/hashicorp/terraform/terraform"
|
2019-02-01 22:47:18 +01:00
|
|
|
"github.com/hashicorp/terraform/version"
|
2018-12-19 20:08:25 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
// FormatVersion represents the version of the json format and will be
|
|
|
|
// incremented for any change to this format that requires changes to a
|
|
|
|
// consuming parser.
|
|
|
|
const FormatVersion = "0.1"
|
|
|
|
|
|
|
|
// Plan is the top-level representation of the json format of a plan. It includes
|
|
|
|
// the complete config and current state.
|
|
|
|
type plan struct {
|
2019-02-01 22:47:18 +01:00
|
|
|
FormatVersion string `json:"format_version,omitempty"`
|
|
|
|
TerraformVersion string `json:"terraform_version,omitempty"`
|
2019-02-11 22:17:03 +01:00
|
|
|
Variables variables `json:"variables,omitempty"`
|
2019-02-01 22:47:18 +01:00
|
|
|
PlannedValues stateValues `json:"planned_values,omitempty"`
|
2019-01-25 18:17:40 +01:00
|
|
|
// ResourceChanges are sorted in a user-friendly order that is undefined at
|
|
|
|
// this time, but consistent.
|
2018-12-19 20:08:25 +01:00
|
|
|
ResourceChanges []resourceChange `json:"resource_changes,omitempty"`
|
|
|
|
OutputChanges map[string]change `json:"output_changes,omitempty"`
|
|
|
|
PriorState json.RawMessage `json:"prior_state,omitempty"`
|
|
|
|
Config json.RawMessage `json:"configuration,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func newPlan() *plan {
|
|
|
|
return &plan{
|
|
|
|
FormatVersion: FormatVersion,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Change is the representation of a proposed change for an object.
|
|
|
|
type change struct {
|
|
|
|
// Actions are the actions that will be taken on the object selected by the
|
|
|
|
// properties below. Valid actions values are:
|
|
|
|
// ["no-op"]
|
|
|
|
// ["create"]
|
|
|
|
// ["read"]
|
|
|
|
// ["update"]
|
|
|
|
// ["delete", "create"]
|
|
|
|
// ["create", "delete"]
|
|
|
|
// ["delete"]
|
|
|
|
// The two "replace" actions are represented in this way to allow callers to
|
|
|
|
// e.g. just scan the list for "delete" to recognize all three situations
|
|
|
|
// where the object will be deleted, allowing for any new deletion
|
|
|
|
// combinations that might be added in future.
|
|
|
|
Actions []string `json:"actions,omitempty"`
|
|
|
|
|
|
|
|
// Before and After are representations of the object value both before and
|
|
|
|
// after the action. For ["create"] and ["delete"] actions, either "before"
|
|
|
|
// or "after" is unset (respectively). For ["no-op"], the before and after
|
|
|
|
// values are identical. The "after" value will be incomplete if there are
|
|
|
|
// values within it that won't be known until after apply.
|
2018-12-20 23:30:18 +01:00
|
|
|
Before json.RawMessage `json:"before,omitempty"`
|
|
|
|
After json.RawMessage `json:"after,omitempty"`
|
|
|
|
AfterUnknown json.RawMessage `json:"after_unknown,omitempty"`
|
2018-12-19 20:08:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
type output struct {
|
2019-01-09 17:59:11 +01:00
|
|
|
Sensitive bool `json:"sensitive"`
|
2018-12-19 20:08:25 +01:00
|
|
|
Value json.RawMessage `json:"value,omitempty"`
|
|
|
|
}
|
|
|
|
|
2019-02-11 22:17:03 +01:00
|
|
|
// variables is the JSON representation of the variables provided to the current
|
|
|
|
// plan.
|
|
|
|
type variables map[string]*variable
|
|
|
|
|
|
|
|
type variable struct {
|
|
|
|
Value json.RawMessage `json:"value,omitempty"`
|
|
|
|
}
|
|
|
|
|
2018-12-19 20:08:25 +01:00
|
|
|
// Marshal returns the json encoding of a terraform plan.
|
|
|
|
func Marshal(
|
|
|
|
config *configs.Config,
|
|
|
|
p *plans.Plan,
|
2019-01-25 00:28:53 +01:00
|
|
|
sf *statefile.File,
|
2018-12-19 20:08:25 +01:00
|
|
|
schemas *terraform.Schemas,
|
2019-03-01 22:59:57 +01:00
|
|
|
stateSchemas *terraform.Schemas,
|
2018-12-19 20:08:25 +01:00
|
|
|
) ([]byte, error) {
|
2019-03-01 22:59:57 +01:00
|
|
|
if stateSchemas == nil {
|
|
|
|
stateSchemas = schemas
|
|
|
|
}
|
2018-12-19 20:08:25 +01:00
|
|
|
|
|
|
|
output := newPlan()
|
2019-02-01 22:47:18 +01:00
|
|
|
output.TerraformVersion = version.String()
|
2018-12-19 20:08:25 +01:00
|
|
|
|
2019-02-11 22:17:03 +01:00
|
|
|
err := output.marshalPlanVariables(p.VariableValues, schemas)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error in marshalPlanVariables: %s", err)
|
|
|
|
}
|
|
|
|
|
2018-12-20 23:30:18 +01:00
|
|
|
// output.PlannedValues
|
2019-02-11 22:17:03 +01:00
|
|
|
err = output.marshalPlannedValues(p.Changes, schemas)
|
2018-12-19 20:08:25 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error in marshalPlannedValues: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// output.ResourceChanges
|
|
|
|
err = output.marshalResourceChanges(p.Changes, schemas)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error in marshalResourceChanges: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// output.OutputChanges
|
|
|
|
err = output.marshalOutputChanges(p.Changes)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error in marshaling output changes: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// output.PriorState
|
2019-03-01 22:59:57 +01:00
|
|
|
output.PriorState, err = jsonstate.Marshal(sf, stateSchemas)
|
2018-12-19 20:08:25 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error marshaling prior state: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// output.Config
|
|
|
|
output.Config, err = jsonconfig.Marshal(config, schemas)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error marshaling config: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// add some polish
|
|
|
|
ret, err := json.MarshalIndent(output, "", " ")
|
|
|
|
return ret, err
|
|
|
|
}
|
|
|
|
|
2019-02-11 22:17:03 +01:00
|
|
|
func (p *plan) marshalPlanVariables(vars map[string]plans.DynamicValue, schemas *terraform.Schemas) error {
|
|
|
|
if len(vars) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
p.Variables = make(variables, len(vars))
|
|
|
|
|
|
|
|
for k, v := range vars {
|
|
|
|
val, err := v.Decode(cty.DynamicPseudoType)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
valJSON, err := ctyjson.Marshal(val, val.Type())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
p.Variables[k] = &variable{
|
|
|
|
Value: valJSON,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-12-19 20:08:25 +01:00
|
|
|
func (p *plan) marshalResourceChanges(changes *plans.Changes, schemas *terraform.Schemas) error {
|
|
|
|
if changes == nil {
|
|
|
|
// Nothing to do!
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
for _, rc := range changes.Resources {
|
|
|
|
var r resourceChange
|
|
|
|
addr := rc.Addr
|
|
|
|
r.Address = addr.String()
|
|
|
|
|
|
|
|
dataSource := addr.Resource.Resource.Mode == addrs.DataResourceMode
|
|
|
|
// We create "delete" actions for data resources so we can clean up
|
|
|
|
// their entries in state, but this is an implementation detail that
|
|
|
|
// users shouldn't see.
|
|
|
|
if dataSource && rc.Action == plans.Delete {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2019-02-20 23:27:49 +01:00
|
|
|
schema, _ := schemas.ResourceTypeConfig(
|
|
|
|
rc.ProviderAddr.ProviderConfig.Type,
|
|
|
|
addr.Resource.Resource.Mode,
|
|
|
|
addr.Resource.Resource.Type,
|
|
|
|
)
|
2018-12-19 20:08:25 +01:00
|
|
|
if schema == nil {
|
|
|
|
return fmt.Errorf("no schema found for %s", r.Address)
|
|
|
|
}
|
|
|
|
|
|
|
|
changeV, err := rc.Decode(schema.ImpliedType())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
var before, after []byte
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
var afterUnknown cty.Value
|
2018-12-19 20:08:25 +01:00
|
|
|
if changeV.Before != cty.NilVal {
|
|
|
|
before, err = ctyjson.Marshal(changeV.Before, changeV.Before.Type())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if changeV.After != cty.NilVal {
|
|
|
|
if changeV.After.IsWhollyKnown() {
|
|
|
|
after, err = ctyjson.Marshal(changeV.After, changeV.After.Type())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
afterUnknown, _ = cty.Transform(changeV.After, func(path cty.Path, val cty.Value) (cty.Value, error) {
|
|
|
|
if val.IsNull() {
|
|
|
|
return cty.False, nil
|
|
|
|
}
|
2018-12-19 20:08:25 +01:00
|
|
|
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
if !val.Type().IsPrimitiveType() {
|
|
|
|
return val, nil // just pass through non-primitives; they already contain our transform results
|
|
|
|
}
|
2018-12-20 23:30:18 +01:00
|
|
|
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
if val.IsKnown() {
|
|
|
|
return cty.False, nil
|
|
|
|
}
|
2018-12-20 23:30:18 +01:00
|
|
|
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
return cty.True, nil
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
filteredAfter := omitUnknowns(changeV.After)
|
2019-01-24 01:14:34 +01:00
|
|
|
if filteredAfter.IsNull() {
|
|
|
|
after = nil
|
|
|
|
} else {
|
|
|
|
after, err = ctyjson.Marshal(filteredAfter, filteredAfter.Type())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
}
|
|
|
|
afterUnknown = unknownAsBool(changeV.After)
|
2018-12-20 23:30:18 +01:00
|
|
|
}
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
}
|
2018-12-20 23:30:18 +01:00
|
|
|
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
a, err := ctyjson.Marshal(afterUnknown, afterUnknown.Type())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-12-20 23:30:18 +01:00
|
|
|
|
2018-12-19 20:08:25 +01:00
|
|
|
r.Change = change{
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
Actions: actionString(rc.Action.String()),
|
2018-12-20 23:30:18 +01:00
|
|
|
Before: json.RawMessage(before),
|
|
|
|
After: json.RawMessage(after),
|
|
|
|
AfterUnknown: a,
|
2018-12-19 20:08:25 +01:00
|
|
|
}
|
2018-12-20 23:30:18 +01:00
|
|
|
|
2019-02-19 22:55:49 +01:00
|
|
|
if rc.DeposedKey != states.NotDeposed {
|
|
|
|
r.Deposed = rc.DeposedKey.String()
|
|
|
|
}
|
2018-12-19 20:08:25 +01:00
|
|
|
|
|
|
|
key := addr.Resource.Key
|
|
|
|
if key != nil {
|
|
|
|
r.Index = key
|
|
|
|
}
|
|
|
|
|
|
|
|
switch addr.Resource.Resource.Mode {
|
|
|
|
case addrs.ManagedResourceMode:
|
|
|
|
r.Mode = "managed"
|
|
|
|
case addrs.DataResourceMode:
|
|
|
|
r.Mode = "data"
|
|
|
|
default:
|
|
|
|
return fmt.Errorf("resource %s has an unsupported mode %s", r.Address, addr.Resource.Resource.Mode.String())
|
|
|
|
}
|
|
|
|
r.ModuleAddress = addr.Module.String()
|
|
|
|
r.Name = addr.Resource.Resource.Name
|
|
|
|
r.Type = addr.Resource.Resource.Type
|
|
|
|
|
|
|
|
p.ResourceChanges = append(p.ResourceChanges, r)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-01-12 00:13:55 +01:00
|
|
|
sort.Slice(p.ResourceChanges, func(i, j int) bool {
|
|
|
|
return p.ResourceChanges[i].Address < p.ResourceChanges[j].Address
|
|
|
|
})
|
|
|
|
|
2018-12-19 20:08:25 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *plan) marshalOutputChanges(changes *plans.Changes) error {
|
|
|
|
if changes == nil {
|
|
|
|
// Nothing to do!
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
p.OutputChanges = make(map[string]change, len(changes.Outputs))
|
|
|
|
for _, oc := range changes.Outputs {
|
|
|
|
changeV, err := oc.Decode()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
var before, after []byte
|
2018-12-20 23:30:18 +01:00
|
|
|
afterUnknown := cty.False
|
2018-12-19 20:08:25 +01:00
|
|
|
if changeV.Before != cty.NilVal {
|
|
|
|
before, err = ctyjson.Marshal(changeV.Before, changeV.Before.Type())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if changeV.After != cty.NilVal {
|
|
|
|
if changeV.After.IsWhollyKnown() {
|
|
|
|
after, err = ctyjson.Marshal(changeV.After, changeV.After.Type())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-12-20 23:30:18 +01:00
|
|
|
} else {
|
|
|
|
afterUnknown = cty.True
|
2018-12-19 20:08:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-20 23:30:18 +01:00
|
|
|
a, _ := ctyjson.Marshal(afterUnknown, afterUnknown.Type())
|
|
|
|
|
|
|
|
c := change{
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
Actions: actionString(oc.Action.String()),
|
2018-12-20 23:30:18 +01:00
|
|
|
Before: json.RawMessage(before),
|
|
|
|
After: json.RawMessage(after),
|
|
|
|
AfterUnknown: a,
|
|
|
|
}
|
|
|
|
|
2018-12-19 20:08:25 +01:00
|
|
|
p.OutputChanges[oc.Addr.OutputValue.Name] = c
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *plan) marshalPlannedValues(changes *plans.Changes, schemas *terraform.Schemas) error {
|
|
|
|
// marshal the planned changes into a module
|
2018-12-20 23:30:18 +01:00
|
|
|
plan, err := marshalPlannedValues(changes, schemas)
|
2018-12-19 20:08:25 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
p.PlannedValues.RootModule = plan
|
|
|
|
|
|
|
|
// marshalPlannedOutputs
|
2018-12-20 23:30:18 +01:00
|
|
|
outputs, err := marshalPlannedOutputs(changes)
|
2018-12-19 20:08:25 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
p.PlannedValues.Outputs = outputs
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
mildwonkey/b-show-state (#20032)
* command/show: properly marshal attribute values to json
marshalAttributeValues in jsonstate and jsonplan packages was returning
a cty.Value, which json/encoding could not marshal. These functions now
convert those cty.Values into json.RawMessages.
* command/jsonplan: planned values should include resources that are not changing
* command/jsonplan: return a filtered list of proposed 'after' attributes
Previously, proposed 'after' attributes were not being shown if the
attributes were not WhollyKnown. jsonplan now iterates through all the
`after` attributes, omitting those which are not wholly known.
The same was roughly true for after_unknown, and that structure is now
correctly populated. In the future we may choose to filter the
after_unknown structure to _only_ display unknown attributes, instead of
all attributes.
* command/jsonconfig: use a unique key for providers so that aliased
providers don't get munged together
This now uses the same "provider" key from configs.Module, e.g.
`providername.provideralias`.
* command/jsonplan: unknownAsBool needs to iterate through objects that are not wholly known
* command/jsonplan: properly display actions as strings according to the RFC,
instead of a plans.Action string.
For example:
a plans.Action string DeleteThenCreate should be displayed as ["delete",
"create"]
Tests have been updated to reflect this.
* command/jsonplan: return "null" for unknown list items.
The length of a list could be meaningful on its own, so we will turn
unknowns into "null". The same is less likely true for maps and objects,
so we will continue to omit unknown values from those.
2019-01-23 20:46:53 +01:00
|
|
|
|
|
|
|
// omitUnknowns recursively walks the src cty.Value and returns a new cty.Value,
|
|
|
|
// omitting any unknowns.
|
|
|
|
func omitUnknowns(val cty.Value) cty.Value {
|
|
|
|
if val.IsWhollyKnown() {
|
|
|
|
return val
|
|
|
|
}
|
|
|
|
|
|
|
|
ty := val.Type()
|
|
|
|
switch {
|
|
|
|
case val.IsNull():
|
|
|
|
return val
|
|
|
|
case !val.IsKnown():
|
|
|
|
return cty.NilVal
|
|
|
|
case ty.IsListType() || ty.IsTupleType() || ty.IsSetType():
|
|
|
|
if val.LengthInt() == 0 {
|
|
|
|
return val
|
|
|
|
}
|
|
|
|
|
|
|
|
var vals []cty.Value
|
|
|
|
it := val.ElementIterator()
|
|
|
|
for it.Next() {
|
|
|
|
_, v := it.Element()
|
|
|
|
newVal := omitUnknowns(v)
|
|
|
|
if newVal != cty.NilVal {
|
|
|
|
vals = append(vals, newVal)
|
|
|
|
} else if newVal == cty.NilVal && ty.IsListType() {
|
|
|
|
// list length may be significant, so we will turn unknowns into nulls
|
|
|
|
vals = append(vals, cty.NullVal(v.Type()))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(vals) == 0 {
|
|
|
|
return cty.NilVal
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case ty.IsListType():
|
|
|
|
return cty.ListVal(vals)
|
|
|
|
case ty.IsTupleType():
|
|
|
|
return cty.TupleVal(vals)
|
|
|
|
default:
|
|
|
|
return cty.SetVal(vals)
|
|
|
|
}
|
|
|
|
case ty.IsMapType() || ty.IsObjectType():
|
|
|
|
var length int
|
|
|
|
switch {
|
|
|
|
case ty.IsMapType():
|
|
|
|
length = val.LengthInt()
|
|
|
|
default:
|
|
|
|
length = len(val.Type().AttributeTypes())
|
|
|
|
}
|
|
|
|
if length == 0 {
|
|
|
|
// If there are no elements then we can't have unknowns
|
|
|
|
return val
|
|
|
|
}
|
|
|
|
vals := make(map[string]cty.Value)
|
|
|
|
it := val.ElementIterator()
|
|
|
|
for it.Next() {
|
|
|
|
k, v := it.Element()
|
|
|
|
newVal := omitUnknowns(v)
|
|
|
|
if newVal != cty.NilVal {
|
|
|
|
vals[k.AsString()] = newVal
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(vals) == 0 {
|
|
|
|
return cty.NilVal
|
|
|
|
}
|
|
|
|
|
|
|
|
switch {
|
|
|
|
case ty.IsMapType():
|
|
|
|
return cty.MapVal(vals)
|
|
|
|
default:
|
|
|
|
return cty.ObjectVal(vals)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return val
|
|
|
|
}
|
|
|
|
|
|
|
|
// recursively iterate through a cty.Value, replacing known values (including
|
|
|
|
// null) with cty.True and unknown values with cty.False.
|
|
|
|
//
|
|
|
|
// TODO:
|
|
|
|
// In the future, we may choose to only return unknown values. At that point,
|
|
|
|
// this will need to convert lists/sets into tuples and maps into objects, so
|
|
|
|
// that the result will have a valid type.
|
|
|
|
func unknownAsBool(val cty.Value) cty.Value {
|
|
|
|
ty := val.Type()
|
|
|
|
switch {
|
|
|
|
case val.IsNull():
|
|
|
|
return cty.False
|
|
|
|
case !val.IsKnown():
|
|
|
|
if ty.IsPrimitiveType() || ty.Equals(cty.DynamicPseudoType) {
|
|
|
|
return cty.True
|
|
|
|
}
|
|
|
|
fallthrough
|
|
|
|
case ty.IsPrimitiveType():
|
|
|
|
return cty.BoolVal(!val.IsKnown())
|
|
|
|
case ty.IsListType() || ty.IsTupleType() || ty.IsSetType():
|
|
|
|
length := val.LengthInt()
|
|
|
|
if length == 0 {
|
|
|
|
// If there are no elements then we can't have unknowns
|
|
|
|
return cty.False
|
|
|
|
}
|
|
|
|
vals := make([]cty.Value, 0, length)
|
|
|
|
it := val.ElementIterator()
|
|
|
|
for it.Next() {
|
|
|
|
_, v := it.Element()
|
|
|
|
vals = append(vals, unknownAsBool(v))
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case ty.IsListType():
|
|
|
|
return cty.ListVal(vals)
|
|
|
|
case ty.IsTupleType():
|
|
|
|
return cty.TupleVal(vals)
|
|
|
|
default:
|
|
|
|
return cty.SetVal(vals)
|
|
|
|
}
|
|
|
|
case ty.IsMapType() || ty.IsObjectType():
|
|
|
|
var length int
|
|
|
|
switch {
|
|
|
|
case ty.IsMapType():
|
|
|
|
length = val.LengthInt()
|
|
|
|
default:
|
|
|
|
length = len(val.Type().AttributeTypes())
|
|
|
|
}
|
|
|
|
if length == 0 {
|
|
|
|
// If there are no elements then we can't have unknowns
|
|
|
|
return cty.False
|
|
|
|
}
|
|
|
|
vals := make(map[string]cty.Value)
|
|
|
|
it := val.ElementIterator()
|
|
|
|
for it.Next() {
|
|
|
|
k, v := it.Element()
|
|
|
|
vals[k.AsString()] = unknownAsBool(v)
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case ty.IsMapType():
|
|
|
|
return cty.MapVal(vals)
|
|
|
|
default:
|
|
|
|
return cty.ObjectVal(vals)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return val
|
|
|
|
}
|
|
|
|
|
|
|
|
func actionString(action string) []string {
|
|
|
|
switch {
|
|
|
|
case action == "NoOp":
|
|
|
|
return []string{"no-op"}
|
|
|
|
case action == "Create":
|
|
|
|
return []string{"create"}
|
|
|
|
case action == "Delete":
|
|
|
|
return []string{"delete"}
|
|
|
|
case action == "Update":
|
|
|
|
return []string{"update"}
|
|
|
|
case action == "CreateThenDelete":
|
|
|
|
return []string{"create", "delete"}
|
|
|
|
case action == "Read":
|
|
|
|
return []string{"read"}
|
|
|
|
case action == "DeleteThenCreate":
|
|
|
|
return []string{"delete", "create"}
|
|
|
|
default:
|
|
|
|
return []string{action}
|
|
|
|
}
|
|
|
|
}
|