Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
123 lines (101 sloc) 3.52 KB
package terraform
import (
"bytes"
"encoding/gob"
"fmt"
"io"
"sync"
"github.com/zclconf/go-cty/cty"
"github.com/hashicorp/terraform/configs"
)
func init() {
gob.Register(make([]interface{}, 0))
gob.Register(make([]map[string]interface{}, 0))
gob.Register(make(map[string]interface{}))
gob.Register(make(map[string]string))
}
// Plan represents a single Terraform execution plan, which contains
// all the information necessary to make an infrastructure change.
//
// A plan has to contain basically the entire state of the world
// necessary to make a change: the state, diff, config, backend config, etc.
// This is so that it can run alone without any other data.
type Plan struct {
// Diff describes the resource actions that must be taken when this
// plan is applied.
Diff *Diff
// Config represents the entire configuration that was present when this
// plan was created.
Config *configs.Config
// State is the Terraform state that was current when this plan was
// created.
//
// It is not allowed to apply a plan that has a stale state, since its
// diff could be outdated.
State *State
// Vars retains the variables that were set when creating the plan, so
// that the same variables can be applied during apply.
Vars map[string]cty.Value
// Targets, if non-empty, contains a set of resource address strings that
// identify graph nodes that were selected as targets for plan.
//
// When targets are set, any graph node that is not directly targeted or
// indirectly targeted via dependencies is excluded from the graph.
Targets []string
// TerraformVersion is the version of Terraform that was used to create
// this plan.
//
// It is not allowed to apply a plan created with a different version of
// Terraform, since the other fields of this structure may be interpreted
// in different ways between versions.
TerraformVersion string
// ProviderSHA256s is a map giving the SHA256 hashes of the exact binaries
// used as plugins for each provider during plan.
//
// These must match between plan and apply to ensure that the diff is
// correctly interpreted, since different provider versions may have
// different attributes or attribute value constraints.
ProviderSHA256s map[string][]byte
// Backend is the backend that this plan should use and store data with.
Backend *BackendState
// Destroy indicates that this plan was created for a full destroy operation
Destroy bool
once sync.Once
}
func (p *Plan) String() string {
buf := new(bytes.Buffer)
buf.WriteString("DIFF:\n\n")
buf.WriteString(p.Diff.String())
buf.WriteString("\n\nSTATE:\n\n")
buf.WriteString(p.State.String())
return buf.String()
}
func (p *Plan) init() {
p.once.Do(func() {
if p.Diff == nil {
p.Diff = new(Diff)
p.Diff.init()
}
if p.State == nil {
p.State = new(State)
p.State.init()
}
if p.Vars == nil {
p.Vars = make(map[string]cty.Value)
}
})
}
// The format byte is prefixed into the plan file format so that we have
// the ability in the future to change the file format if we want for any
// reason.
const planFormatMagic = "tfplan"
const planFormatVersion byte = 2
// ReadPlan reads a plan structure out of a reader in the format that
// was written by WritePlan.
func ReadPlan(src io.Reader) (*Plan, error) {
return nil, fmt.Errorf("terraform.ReadPlan is no longer in use; use planfile.Open instead")
}
// WritePlan writes a plan somewhere in a binary format.
func WritePlan(d *Plan, dst io.Writer) error {
return fmt.Errorf("terraform.WritePlan is no longer in use; use planfile.Create instead")
}
You can’t perform that action at this time.