terraform

Commit Graph

Author	SHA1	Message	Date
Radek Simko	0fe906fa8c	make copyrightfix	3 months ago
James Bardin	807e084130	final renaming for function results	1 year ago
James Bardin	a6ec17cb77	rename function results table Remove "provider" from the function results fields since it's not going to be exclusively used for providers any longer.	1 year ago
James Bardin	d016070564	move function results hashing to lang We need to abstract the function results verification to use internally too, so start by moving it out of the providers code.	1 year ago
Liam Cervante	063757ff45	stacks: refactor plan, state, and removed tracking with tree structures for efficient lookups (#36850 )	1 year ago
Liam Cervante	a384d2daa7	stacks: fix deferred data sources and unknown component applies (#35876 )	2 years ago
Liam Cervante	bfa320c7b0	stacks: represent ephemeral inputs and outputs as null (#35824 ) * stacks: represent ephemeral inputs and outputs as null * quick fix: remove unnecessary check	2 years ago
James Bardin	384f2d4fab	update collections to use for-range method	2 years ago
Liam Cervante	b38fd17cf9	stacks: emit removal notices for empty components (#35738 ) * stacks: emit removal notices for empty components * fix tests and checks	2 years ago
Liam Cervante	d142486a40	stacks: expand plan and apply outputs for inputs (#35724 )	2 years ago
Liam Cervante	73e3f8096b	stacks: complete stack output implementation for plan and apply (#35723 )	2 years ago
Liam Cervante	b6ac98122b	stacks: refactor shared functionality in prep for removed blocks (#35670 )	2 years ago
Liam Cervante	50233d7a78	stacks: support sensitive input values in planned changes (#35640 ) * stacks: support sensitive input values in planned changes * stacks: Fix panic when applying sensitive inputs The stacks-specific check that a given plan's input variable values remain unchanged at apply time would previously panic when given a marked value. Marks are not important for this check, so we simply remove them to ensure that it passes. This seems in line with how AssertObjectCompatible works, which I'm taking as precedent. The new test added in this commit panics without the corresponding code change. --------- Co-authored-by: Alisdair McDiarmid <alisdair@users.noreply.github.com>	2 years ago
Liam Cervante	f1ae07b1af	stacks: add support for provider functions in .tfstack.hcl files (#35610 ) * stacks: fix bug preventing cross-provider move refactorings * also make provider functions work * stacks: add support for provider functions in .tfstack.hcl files	2 years ago
Liam Cervante	0c67edd598	stacks: ensure input values for components don't change between plan and apply (#35489 ) * stacks: ensure input values for components don't change between plan and apply * skip ephemeral values	2 years ago
Liam Cervante	87bbc47737	stacks: include plan mode in stacks plan format (#35405 ) * stacks: include plan mode in stacks plan format * fix tests * fix missed files	2 years ago
Martin Atkins	ec2510fc3d	stacks: Track raw stack as separate messages in raw plan Previously we had the entire raw prior state serialized as part of the "plan header" message in the raw plan, which meant that the maximum state size was constrained by the maximum allowed gRPC message size. Instead now we'll use a separate raw plan element for each raw prior state element, so that we're limited only in the size of individual items rather than size of the state as a whole. This deals with the last remaining (non-deprecated) case where our RPC protocol tries to pack an entire raw state or plan into a single protobuf message, and so we're now standardized on using a streaming approach in all cases.	2 years ago
Alisdair McDiarmid	d828776757	stacks+rpcapi: Load prior state and plan separately Previously we expected clients to provide an inline raw prior state to PlanStackChanges and an inline raw plan to ApplyStackChanges, which was a simpler design but meant that we might end up generating a state or plan that's too large to be submitted in a single gRPC request, which would then be difficult to resolve. Instead we'll offer separate RPC functions for loading raw state and plan using a gRPC streaming approach, which better mirrors the streaming approach we use to _emit_ these artifacts. Although we don't actually need this benefit right now, this makes it possible in principle for a client that's running PlanStackChanges to feed back the raw planned actions concurrently into OpenPlan and thus avoid buffering the whole plan on the client side at all. This required resolving the pre-existing FIXME about the inconsistency where stackeval wants a raw plan for apply but expects the caller to have dealt with loading the prior state for planning. Here it's resolved in the direction of the caller (rpcapi) always being responsible for loading both artifacts, because that means we can continue supporting the old inline approach for a while without that complexity having to infect the lower layers. Ideally we should remove the legacy approach before this API becomes constrained by compatibility promises, but I've preserved the old API for now to give us some flexibility in when we update the existing clients of this API to use the new approach. Co-authored-by: Martin Atkins <mart@degeneration.co.uk>	2 years ago
Daniel Schmidt	b62a67394b	stacks: save plantimestamp to plan	2 years ago
Liam Cervante	0f0414d484	Fix partial address representation in plan for deferred actions (#34966 ) * Fix partial address representation in plan * reflect new type in stacks	2 years ago
Martin Atkins	e74896bd24	stackruntime: Handle apply-time-specified input variables When the topmost stack configuration declares an ephemeral input variable, its values must be provided separately for each of the plan and apply phases. Therefore here we extend the API to allow specifying input variable values during the apply phase, and add rules to check whether all of the apply-time-required input variables have been specified and whether any non-ephemeral variables are either unspecified or re-specified with equal values during the apply phase. This also extends the FindStackConfigurationComponents response to include more metadata about the input variables and output values so that a caller can know which ones are ephemeral. The name of that RPC function had already become a little too specific with the inclusion of embedded stack information and is even moreso now; we might choose to rename it to something more generic like "AnalyzeStackConfiguration" in future, but that'd be a breaking change and therefore requires more coordination.	2 years ago
Liam Cervante	9b95898f63	stacks: emit events for deferred actions (#35325 ) * stacks: emit events for deferred actions * deferral allowed is always on * Update internal/rpcapi/stacks.go Co-authored-by: Daniel Schmidt <danielmschmidt92@gmail.com> --------- Co-authored-by: Daniel Schmidt <danielmschmidt92@gmail.com>	2 years ago
Daniel Schmidt	59ead5356f	stacks: update RPC APIs with deferral information (#35125 ) * stacks: add deferred resource instance planned change to protobuf * stacks: add deferred resource instance to stack plan sequence * stacks: add planned change for deferred actions * stacks: refactor planned change resource instance planned moving the components out of the main function definition so that we can reuse the implementation for deferred resource instances which wraps the message used for PlannedChangeResourceInstancePlanned * stacks: track deferred changes in stackplan * add simple tests * fix tests * address comments --------- Co-authored-by: Liam Cervante <liam.cervante@hashicorp.com>	2 years ago
CJ Horton	5a750561e6	round-trip check results through stack plans Components expect that check results will be round-tripped through the plan in order to update unknown check results during the apply. We hadn't wired this up for stack plans, resulting in panics when the apply tries to update a check status that doesn't exist.	2 years ago
Martin Atkins	884e1fb2a4	terraform: Plans can be "complete" and "applyable" These ideas are both already implied by some logic elsewhere in the system, but until now we didn't have the decision logic centralized in a single place that could therefore evolve over time without necessarily always updating every caller together. We'll now have the modules runtime produce its own boolean ruling about each characteristic, which callers can rely on for the mechanical decision-making of whether to offer the user an "approve" prompt, and whether to remind the user after apply that it was an incomplete plan that will probably therefore need at least one more plan/apply round to converge. The "Applyable" flag directly replaces the previous method Plan.CanApply, with equivalent logic. Making this a field instead of a method means that we can freeze it as part of a saved plan, rather than recalculating it when we reload the plan, and we can export the field value in our export formats like JSON while ensuring it'll always be consistent with what Terraform is using internally. Callers can (and should) still use other context in the plan to return more tailored messages for specific situations they already know about that might be useful to users, but with these flags as a baseline callers can now just fall back to a generic presentation when encountering a situation they don't yet understand, rather than making the wrong decision and causing something strange to happen. That is: a lack of awareness of a new rule will now cause just a generic message in the UI, rather than incorrect behavior. This commit mostly just deals with populating the flags, and then all of the direct consequences of that on our various tests. Further changes to actually make use of these flags elsewhere in the system will follow in later commits, both in this repository and in other repositories.	2 years ago
Martin Atkins	a4d61733f6	stackplan: Include extra info in raw component instance plan We'll now track the planned action, the component addresses we depend on, and the planned output values.	2 years ago
Martin Atkins	972f1c0678	stackplan: Track provider config for every resource instance change Previously we were still partially relying on the record of this in the embedded planproto object, but since we're now allowing "planned changes" that don't actually include a change in that traditional sense we need to track the provider configuration address separately as a top-level field. As with some of the addresses before, this means we're now storing the provider config address redundantly in two places when there _is_ a planproto change. Hopefully we'll improve that someday, but we don't need to sweat it too much right now because this only affects the internal raw plan format that is not subject to any compatibility promises between releases, so we can freely change it in any future version.	3 years ago
Martin Atkins	4e34e6ebfa	stacks: Track prior state for all resource instance objects Previously our raw plan data structure only included information about resource instances that have planned actions, which meant we were missing those which only get their state updated during refresh and don't actually need any real work done. Now we'll track everything, accepting that some "planned changes" for resource instance objects will not actually include a planned change in the typical sense, and instead only represent a state update.	3 years ago
Martin Atkins	8fd29e9439	stacks: Preserve prior state from plan to apply We need to retain the prior state (in a form that Terraform Core's modules runtime can accept) between the plan and apply phases because Terraform uses it to verify that the provider's "final plan" is consistent with the initial plan. We previously tried to do this by reusing the "old" value from the planned change, but that's not really possible in practice because of the historical implementation detail that Terraform wants state information in a JSON format and plan information in MessagePack. This also contains the beginnings of handling the "discarding" of unrecognized keys from the state data structures, although we'll probably need to do more in that area later since this is just the bare minimum.	3 years ago
Martin Atkins	69aa51b9ff	stackruntime: Fix some quirks of data sent from plan to apply We previously took a few shortcuts just to more quickly produce a proof of concept. This gets us considerably closer to a properly-working handoff from plan to apply, at least for create, update, and replace actions. Destroying stuff that's been removed from the configuration will take some further work since currently everything we do is driven by objects in the configuration. That will follow in later commits.	3 years ago
Martin Atkins	c67920ce4b	stackplan: Add HashiCorp copyright comments	3 years ago
Martin Atkins	d99985720f	stacks: Carry input variable values from plan to apply We need to preserve the input variable values provided during the plan phase so we can reuse them during the apply phase to recalculate derived results based on new information learned during the apply process. We also need to recalculate the input values for individual components during the apply phase, so we can react to previously-unknown values that come from other upstream components.	3 years ago
Martin Atkins	f34633577f	stackplan: LoadFromProto must allocate its component map Previously this was panicking later on in the function when trying to insert into a nil map.	3 years ago
Martin Atkins	3c5a2ea7e5	stackplan: Use comparable version strings for plan version checking Previously we were comparing version.String() with version.SemVer.String(), which doesn't match because the latter excludes any prerelease version suffix.	3 years ago
Martin Atkins	ba8af34679	stackplan: Stub of runtime models for representing plans This package includes both some model types to represent plans (and parts thereof) in memory, and logic for translating between the in-memory representation and our protocol-buffers-based storage serialization. Unlike the traditional saved plan file format, the stacks model for planning is slightly asymmetrical: while constructing the plan the system will emit chunks of the overall plan piecemeal as PlannedChange values, streamed to the rpcapi client. When reloading that plan to apply it, the client must provide all of the raw plan blobs in sequence which we can then decode one by one to construct a single Plan object covering the entire effect of the plan. Another intentional asymmetry is that PlannedChange includes enough information to produce both the raw internal plan representation and the public-facing plan description, whereas Plan only includes the subset of information actually required for Terraform Core to apply the plan, from the raw internal representation exclusively.	3 years ago

35 Commits (stacks-variable-validations)