diff options
Diffstat (limited to 'vendor/github.com/hashicorp/terraform/states/statefile/version2.go')
-rw-r--r-- | vendor/github.com/hashicorp/terraform/states/statefile/version2.go | 209 |
1 files changed, 209 insertions, 0 deletions
diff --git a/vendor/github.com/hashicorp/terraform/states/statefile/version2.go b/vendor/github.com/hashicorp/terraform/states/statefile/version2.go new file mode 100644 index 0000000..6fe2ab8 --- /dev/null +++ b/vendor/github.com/hashicorp/terraform/states/statefile/version2.go | |||
@@ -0,0 +1,209 @@ | |||
1 | package statefile | ||
2 | |||
3 | import ( | ||
4 | "encoding/json" | ||
5 | "fmt" | ||
6 | "sync" | ||
7 | |||
8 | "github.com/hashicorp/terraform/tfdiags" | ||
9 | ) | ||
10 | |||
11 | func readStateV2(src []byte) (*File, tfdiags.Diagnostics) { | ||
12 | var diags tfdiags.Diagnostics | ||
13 | sV2 := &stateV2{} | ||
14 | err := json.Unmarshal(src, sV2) | ||
15 | if err != nil { | ||
16 | diags = diags.Append(jsonUnmarshalDiags(err)) | ||
17 | return nil, diags | ||
18 | } | ||
19 | |||
20 | file, prepDiags := prepareStateV2(sV2) | ||
21 | diags = diags.Append(prepDiags) | ||
22 | return file, diags | ||
23 | } | ||
24 | |||
25 | func prepareStateV2(sV2 *stateV2) (*File, tfdiags.Diagnostics) { | ||
26 | var diags tfdiags.Diagnostics | ||
27 | sV3, err := upgradeStateV2ToV3(sV2) | ||
28 | if err != nil { | ||
29 | diags = diags.Append(tfdiags.Sourceless( | ||
30 | tfdiags.Error, | ||
31 | upgradeFailed, | ||
32 | fmt.Sprintf("Error upgrading state file format from version 2 to version 3: %s.", err), | ||
33 | )) | ||
34 | return nil, diags | ||
35 | } | ||
36 | |||
37 | file, prepDiags := prepareStateV3(sV3) | ||
38 | diags = diags.Append(prepDiags) | ||
39 | return file, diags | ||
40 | } | ||
41 | |||
42 | // stateV2 is a representation of the legacy JSON state format version 2. | ||
43 | // | ||
44 | // It is only used to read version 2 JSON files prior to upgrading them to | ||
45 | // the current format. | ||
46 | type stateV2 struct { | ||
47 | // Version is the state file protocol version. | ||
48 | Version int `json:"version"` | ||
49 | |||
50 | // TFVersion is the version of Terraform that wrote this state. | ||
51 | TFVersion string `json:"terraform_version,omitempty"` | ||
52 | |||
53 | // Serial is incremented on any operation that modifies | ||
54 | // the State file. It is used to detect potentially conflicting | ||
55 | // updates. | ||
56 | Serial int64 `json:"serial"` | ||
57 | |||
58 | // Lineage is set when a new, blank state is created and then | ||
59 | // never updated. This allows us to determine whether the serials | ||
60 | // of two states can be meaningfully compared. | ||
61 | // Apart from the guarantee that collisions between two lineages | ||
62 | // are very unlikely, this value is opaque and external callers | ||
63 | // should only compare lineage strings byte-for-byte for equality. | ||
64 | Lineage string `json:"lineage"` | ||
65 | |||
66 | // Remote is used to track the metadata required to | ||
67 | // pull and push state files from a remote storage endpoint. | ||
68 | Remote *remoteStateV2 `json:"remote,omitempty"` | ||
69 | |||
70 | // Backend tracks the configuration for the backend in use with | ||
71 | // this state. This is used to track any changes in the backend | ||
72 | // configuration. | ||
73 | Backend *backendStateV2 `json:"backend,omitempty"` | ||
74 | |||
75 | // Modules contains all the modules in a breadth-first order | ||
76 | Modules []*moduleStateV2 `json:"modules"` | ||
77 | } | ||
78 | |||
79 | type remoteStateV2 struct { | ||
80 | // Type controls the client we use for the remote state | ||
81 | Type string `json:"type"` | ||
82 | |||
83 | // Config is used to store arbitrary configuration that | ||
84 | // is type specific | ||
85 | Config map[string]string `json:"config"` | ||
86 | } | ||
87 | |||
88 | type outputStateV2 struct { | ||
89 | // Sensitive describes whether the output is considered sensitive, | ||
90 | // which may lead to masking the value on screen in some cases. | ||
91 | Sensitive bool `json:"sensitive"` | ||
92 | // Type describes the structure of Value. Valid values are "string", | ||
93 | // "map" and "list" | ||
94 | Type string `json:"type"` | ||
95 | // Value contains the value of the output, in the structure described | ||
96 | // by the Type field. | ||
97 | Value interface{} `json:"value"` | ||
98 | |||
99 | mu sync.Mutex | ||
100 | } | ||
101 | |||
102 | type moduleStateV2 struct { | ||
103 | // Path is the import path from the root module. Modules imports are | ||
104 | // always disjoint, so the path represents amodule tree | ||
105 | Path []string `json:"path"` | ||
106 | |||
107 | // Locals are kept only transiently in-memory, because we can always | ||
108 | // re-compute them. | ||
109 | Locals map[string]interface{} `json:"-"` | ||
110 | |||
111 | // Outputs declared by the module and maintained for each module | ||
112 | // even though only the root module technically needs to be kept. | ||
113 | // This allows operators to inspect values at the boundaries. | ||
114 | Outputs map[string]*outputStateV2 `json:"outputs"` | ||
115 | |||
116 | // Resources is a mapping of the logically named resource to | ||
117 | // the state of the resource. Each resource may actually have | ||
118 | // N instances underneath, although a user only needs to think | ||
119 | // about the 1:1 case. | ||
120 | Resources map[string]*resourceStateV2 `json:"resources"` | ||
121 | |||
122 | // Dependencies are a list of things that this module relies on | ||
123 | // existing to remain intact. For example: an module may depend | ||
124 | // on a VPC ID given by an aws_vpc resource. | ||
125 | // | ||
126 | // Terraform uses this information to build valid destruction | ||
127 | // orders and to warn the user if they're destroying a module that | ||
128 | // another resource depends on. | ||
129 | // | ||
130 | // Things can be put into this list that may not be managed by | ||
131 | // Terraform. If Terraform doesn't find a matching ID in the | ||
132 | // overall state, then it assumes it isn't managed and doesn't | ||
133 | // worry about it. | ||
134 | Dependencies []string `json:"depends_on"` | ||
135 | } | ||
136 | |||
137 | type resourceStateV2 struct { | ||
138 | // This is filled in and managed by Terraform, and is the resource | ||
139 | // type itself such as "mycloud_instance". If a resource provider sets | ||
140 | // this value, it won't be persisted. | ||
141 | Type string `json:"type"` | ||
142 | |||
143 | // Dependencies are a list of things that this resource relies on | ||
144 | // existing to remain intact. For example: an AWS instance might | ||
145 | // depend on a subnet (which itself might depend on a VPC, and so | ||
146 | // on). | ||
147 | // | ||
148 | // Terraform uses this information to build valid destruction | ||
149 | // orders and to warn the user if they're destroying a resource that | ||
150 | // another resource depends on. | ||
151 | // | ||
152 | // Things can be put into this list that may not be managed by | ||
153 | // Terraform. If Terraform doesn't find a matching ID in the | ||
154 | // overall state, then it assumes it isn't managed and doesn't | ||
155 | // worry about it. | ||
156 | Dependencies []string `json:"depends_on"` | ||
157 | |||
158 | // Primary is the current active instance for this resource. | ||
159 | // It can be replaced but only after a successful creation. | ||
160 | // This is the instances on which providers will act. | ||
161 | Primary *instanceStateV2 `json:"primary"` | ||
162 | |||
163 | // Deposed is used in the mechanics of CreateBeforeDestroy: the existing | ||
164 | // Primary is Deposed to get it out of the way for the replacement Primary to | ||
165 | // be created by Apply. If the replacement Primary creates successfully, the | ||
166 | // Deposed instance is cleaned up. | ||
167 | // | ||
168 | // If there were problems creating the replacement Primary, the Deposed | ||
169 | // instance and the (now tainted) replacement Primary will be swapped so the | ||
170 | // tainted replacement will be cleaned up instead. | ||
171 | // | ||
172 | // An instance will remain in the Deposed list until it is successfully | ||
173 | // destroyed and purged. | ||
174 | Deposed []*instanceStateV2 `json:"deposed"` | ||
175 | |||
176 | // Provider is used when a resource is connected to a provider with an alias. | ||
177 | // If this string is empty, the resource is connected to the default provider, | ||
178 | // e.g. "aws_instance" goes with the "aws" provider. | ||
179 | // If the resource block contained a "provider" key, that value will be set here. | ||
180 | Provider string `json:"provider"` | ||
181 | |||
182 | mu sync.Mutex | ||
183 | } | ||
184 | |||
185 | type instanceStateV2 struct { | ||
186 | // A unique ID for this resource. This is opaque to Terraform | ||
187 | // and is only meant as a lookup mechanism for the providers. | ||
188 | ID string `json:"id"` | ||
189 | |||
190 | // Attributes are basic information about the resource. Any keys here | ||
191 | // are accessible in variable format within Terraform configurations: | ||
192 | // ${resourcetype.name.attribute}. | ||
193 | Attributes map[string]string `json:"attributes"` | ||
194 | |||
195 | // Meta is a simple K/V map that is persisted to the State but otherwise | ||
196 | // ignored by Terraform core. It's meant to be used for accounting by | ||
197 | // external client code. The value here must only contain Go primitives | ||
198 | // and collections. | ||
199 | Meta map[string]interface{} `json:"meta"` | ||
200 | |||
201 | // Tainted is used to mark a resource for recreation. | ||
202 | Tainted bool `json:"tainted"` | ||
203 | } | ||
204 | |||
205 | type backendStateV2 struct { | ||
206 | Type string `json:"type"` // Backend type | ||
207 | ConfigRaw json.RawMessage `json:"config"` // Backend raw config | ||
208 | Hash int `json:"hash"` // Hash of portion of configuration from config files | ||
209 | } | ||