| // Copyright (c) The OpenTofu Authors | |
| // SPDX-License-Identifier: MPL-2.0 | |
| // Copyright (c) 2023 HashiCorp, Inc. | |
| // SPDX-License-Identifier: MPL-2.0 | |
| package refactoring | |
| import ( | |
| "fmt" | |
| "github.com/opentofu/opentofu/internal/addrs" | |
| "github.com/opentofu/opentofu/internal/configs" | |
| "github.com/opentofu/opentofu/internal/states" | |
| "github.com/opentofu/opentofu/internal/tfdiags" | |
| ) | |
| type MoveStatement struct { | |
| From, To *addrs.MoveEndpointInModule | |
| DeclRange tfdiags.SourceRange | |
| // Implied is true for statements produced by ImpliedMoveStatements, and | |
| // false for statements produced by FindMoveStatements. | |
| // | |
| // An "implied" statement is one that has no explicit "moved" block in | |
| // the configuration and was instead generated automatically based on a | |
| // comparison between current configuration and previous run state. | |
| // For implied statements, the DeclRange field contains the source location | |
| // of something in the source code that implied the statement, in which | |
| // case it would probably be confusing to show that source range to the | |
| // user, e.g. in an error message, without clearly mentioning that it's | |
| // related to an implied move statement. | |
| Implied bool | |
| } | |
| // FindMoveStatements recurses through the modules of the given configuration | |
| // and returns a flat set of all "moved" blocks defined within, in a | |
| // deterministic but undefined order. | |
| func FindMoveStatements(rootCfg *configs.Config) []MoveStatement { | |
| return findMoveStatements(rootCfg, nil) | |
| } | |
| func findMoveStatements(cfg *configs.Config, into []MoveStatement) []MoveStatement { | |
| modAddr := cfg.Path | |
| for _, mc := range cfg.Module.Moved { | |
| fromAddr, toAddr := addrs.UnifyMoveEndpoints(modAddr, mc.From, mc.To) | |
| if fromAddr == nil || toAddr == nil { | |
| // Invalid combination should've been caught during original | |
| // configuration decoding, in the configs package. | |
| panic(fmt.Sprintf("incompatible move endpoints in %s", mc.DeclRange)) | |
| } | |
| into = append(into, MoveStatement{ | |
| From: fromAddr, | |
| To: toAddr, | |
| DeclRange: tfdiags.SourceRangeFromHCL(mc.DeclRange), | |
| Implied: false, | |
| }) | |
| } | |
| for _, childCfg := range cfg.Children { | |
| into = findMoveStatements(childCfg, into) | |
| } | |
| return into | |
| } | |
| // ImpliedMoveStatements compares addresses in the given state with addresses | |
| // in the given configuration and potentially returns additional MoveStatement | |
| // objects representing moves we infer automatically, even though they aren't | |
| // explicitly recorded in the configuration. | |
| // | |
| // We do this primarily for backward compatibility with behaviors of Terraform | |
| // versions prior to introducing explicit "moved" blocks. Specifically, this | |
| // function aims to achieve the same result as the "NodeCountBoundary" | |
| // heuristic from Terraform v1.0 and earlier, where adding or removing the | |
| // "count" meta-argument from an already-created resource can automatically | |
| // preserve the zeroth or the NoKey instance, depending on the direction of | |
| // the change. We do this only for resources that aren't mentioned already | |
| // in at least one explicit move statement. | |
| // | |
| // As with the previous-version heuristics it replaces, this is a best effort | |
| // and doesn't handle all situations. An explicit move statement is always | |
| // preferred, but our goal here is to match exactly the same cases that the | |
| // old heuristic would've matched, to retain compatibility for existing modules. | |
| // | |
| // We should think very hard before adding any _new_ implication rules for | |
| // moved statements. | |
| func ImpliedMoveStatements(cfg *configs.Config, prevRunState *states.State, explicitStmts []MoveStatement) []MoveStatement { | |
| modAddr := cfg.Path | |
| into := make([]MoveStatement, 0) | |
| // Create implied move statements for module calls. We're typically | |
| // looking for module where meta-arguments were changed to see if they | |
| // can be moved without an explicit moved block. If there's an existing | |
| // explicit move statement for the module, we don't create an implied move statement. | |
| for modCallName, modCallCfg := range cfg.Module.ModuleCalls { | |
| into = append(into, impliedMoveStatementsForModules(prevRunState, cfg, modCallName, modCallCfg, explicitStmts)...) | |
| } | |
| // There can be potentially many instances of the module, so we need | |
| // to consider each of them separately. | |
| for _, modState := range prevRunState.ModuleInstances(modAddr) { | |
| // What we're looking for here is either a no-key resource instance | |
| // where the configuration has count set or a zero-key resource | |
| // instance where the configuration _doesn't_ have count set. | |
| // If so, we'll generate a statement replacing no-key with zero-key or | |
| // vice-versa. | |
| into = append(into, impliedMoveStatementsForModuleResources(cfg, modState, explicitStmts)...) | |
| } | |
| for _, childCfg := range cfg.Children { | |
| into = append(into, ImpliedMoveStatements(childCfg, prevRunState, explicitStmts)...) | |
| } | |
| return into | |
| } | |
| // impliedMoveStatementsForModules creates implied move statements for module calls. | |
| func impliedMoveStatementsForModules( | |
| prevRunState *states.State, | |
| parentCfg *configs.Config, | |
| modCallName string, | |
| modCallCfg *configs.ModuleCall, | |
| explicitStmts []MoveStatement, | |
| ) []MoveStatement { | |
| var into []MoveStatement | |
| var toKey addrs.InstanceKey | |
| approxSrcRange := tfdiags.SourceRangeFromHCL(modCallCfg.DeclRange) | |
| // Use the configuration to determine the instance key to | |
| // use for the implied move `To statement. | |
| switch { | |
| case modCallCfg.Count != nil: | |
| // If we have a count expression then we'll use _that_ as | |
| // a slightly-more-precise approximate source range. | |
| approxSrcRange = tfdiags.SourceRangeFromHCL(modCallCfg.Count.Range()) | |
| toKey = addrs.IntKey(0) | |
| case modCallCfg.Count == nil && modCallCfg.ForEach == nil: // no repetition at all | |
| toKey = addrs.NoKey | |
| default: | |
| // Other combinations of meta-arguments are not supported. | |
| return into | |
| } | |
| // Get the module address | |
| modAddr := parentCfg.Path.Child(modCallName) | |
| // Iterate over all module instances, that can be generated by | |
| // meta-arguments like count or for_each on the saved state for the module. | |
| for _, modState := range prevRunState.ModuleInstances(modAddr) { | |
| callerAddr, callAddr := modState.Addr.CallInstance() | |
| absCallAddr := addrs.AbsModuleCall{ | |
| Module: callerAddr, | |
| Call: callAddr.Call, | |
| } | |
| // Only one instance of the module can be dealt, because moving from single | |
| // to repeated can't support multiple instances. The other instances are going | |
| // to be removed or created, depending on the direction of the change. | |
| fromKey := callAddr.Key | |
| if fromKey != addrs.NoKey && fromKey != addrs.IntKey(0) { | |
| continue | |
| } | |
| // We mustn't generate an implied statement if the user already | |
| // wrote an explicit statement referring to this module, | |
| // because they may wish to select an instance key other than | |
| // zero as the one to retain. If the instance key from the state | |
| // equals the instance key from the configuration, then we don't | |
| // need to generate an implied statement. | |
| if fromKey == toKey || haveMoveStatementForModule(modState.Addr, explicitStmts) { | |
| continue | |
| } | |
| fromAddr := absCallAddr.Instance(fromKey) | |
| toAddr := absCallAddr.Instance(toKey) | |
| into = append(into, MoveStatement{ | |
| From: addrs.ImpliedMoveStatementEndpoint(fromAddr, approxSrcRange), | |
| To: addrs.ImpliedMoveStatementEndpoint(toAddr, approxSrcRange), | |
| DeclRange: approxSrcRange, | |
| Implied: true, | |
| }) | |
| } | |
| return into | |
| } | |
| // impliedMoveStatementsForModuleResources creates implied move statements for module resources. | |
| func impliedMoveStatementsForModuleResources(cfg *configs.Config, modState *states.Module, explicitStmts []MoveStatement) []MoveStatement { | |
| var into []MoveStatement | |
| for _, rState := range modState.Resources { | |
| rAddr := rState.Addr | |
| rCfg := cfg.Module.ResourceByAddr(rAddr.Resource) | |
| if rCfg == nil { | |
| // If there's no configuration at all then there can't be any | |
| // automatic move fixup to do. | |
| continue | |
| } | |
| approxSrcRange := tfdiags.SourceRangeFromHCL(rCfg.DeclRange) | |
| // NOTE: We're intentionally not checking to see whether the | |
| // "to" addresses in our implied statements already have | |
| // instances recorded in state, because ApplyMoves should | |
| // deal with such conflicts in a deterministic way for both | |
| // explicit and implicit moves, and we'd rather have that | |
| // handled all in one place. | |
| var fromKey, toKey addrs.InstanceKey | |
| switch { | |
| case rCfg.Count != nil: | |
| // If we have a count expression then we'll use _that_ as | |
| // a slightly-more-precise approximate source range. | |
| approxSrcRange = tfdiags.SourceRangeFromHCL(rCfg.Count.Range()) | |
| if riState := rState.Instances[addrs.NoKey]; riState != nil { | |
| fromKey = addrs.NoKey | |
| toKey = addrs.IntKey(0) | |
| } | |
| case rCfg.Count == nil && rCfg.ForEach == nil: // no repetition at all | |
| if riState := rState.Instances[addrs.IntKey(0)]; riState != nil { | |
| fromKey = addrs.IntKey(0) | |
| toKey = addrs.NoKey | |
| } | |
| } | |
| if fromKey != toKey { | |
| // We mustn't generate an implied statement if the user already | |
| // wrote an explicit statement referring to this resource, | |
| // because they may wish to select an instance key other than | |
| // zero as the one to retain. | |
| if !haveMoveStatementForResource(rAddr, explicitStmts) { | |
| into = append(into, MoveStatement{ | |
| From: addrs.ImpliedMoveStatementEndpoint(rAddr.Instance(fromKey), approxSrcRange), | |
| To: addrs.ImpliedMoveStatementEndpoint(rAddr.Instance(toKey), approxSrcRange), | |
| DeclRange: approxSrcRange, | |
| Implied: true, | |
| }) | |
| } | |
| } | |
| } | |
| return into | |
| } | |
| func (s *MoveStatement) ObjectKind() addrs.MoveEndpointKind { | |
| // addrs.UnifyMoveEndpoints guarantees that both of our addresses have | |
| // the same kind, so we can just arbitrary use From and assume To will | |
| // match it. | |
| return s.From.ObjectKind() | |
| } | |
| // Name is used internally for displaying the statement graph | |
| func (s *MoveStatement) Name() string { | |
| return fmt.Sprintf("%s->%s", s.From, s.To) | |
| } | |
| func haveMoveStatementForResource(addr addrs.AbsResource, stmts []MoveStatement) bool { | |
| // This is not a particularly optimal way to answer this question, | |
| // particularly since our caller calls this function in a loop already, | |
| // but we expect the total number of explicit statements to be small | |
| // in any reasonable OpenTofu configuration and so a more complicated | |
| // approach wouldn't be justified here. | |
| for _, stmt := range stmts { | |
| if stmt.From.SelectsResource(addr) { | |
| return true | |
| } | |
| if stmt.To.SelectsResource(addr) { | |
| return true | |
| } | |
| } | |
| return false | |
| } | |
| func haveMoveStatementForModule(addr addrs.ModuleInstance, stmts []MoveStatement) bool { | |
| // This is not a particularly optimal way to answer this question, | |
| // particularly since our caller calls this function in a loop already, | |
| // but we expect the total number of explicit statements to be small | |
| // in any reasonable OpenTofu configuration and so a more complicated | |
| // approach wouldn't be justified here. | |
| for _, stmt := range stmts { | |
| if stmt.From.SelectsModule(addr) { | |
| return true | |
| } | |
| if stmt.To.SelectsModule(addr) { | |
| return true | |
| } | |
| } | |
| return false | |
| } |