311 lines
11 KiB
Go
311 lines
11 KiB
Go
package refactoring
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
|
|
"github.com/hashicorp/terraform/internal/addrs"
|
|
"github.com/hashicorp/terraform/internal/dag"
|
|
"github.com/hashicorp/terraform/internal/logging"
|
|
"github.com/hashicorp/terraform/internal/states"
|
|
)
|
|
|
|
// ApplyMoves modifies in-place the given state object so that any existing
|
|
// objects that are matched by a "from" argument of one of the move statements
|
|
// will be moved to instead appear at the "to" argument of that statement.
|
|
//
|
|
// The result is a map from the unique key of each absolute address that was
|
|
// either the source or destination of a move to a MoveResult describing
|
|
// what happened at that address.
|
|
//
|
|
// ApplyMoves does not have any error situations itself, and will instead just
|
|
// ignore any unresolvable move statements. Validation of a set of moves is
|
|
// a separate concern applied to the configuration, because validity of
|
|
// moves is always dependent only on the configuration, not on the state.
|
|
//
|
|
// ApplyMoves expects exclusive access to the given state while it's running.
|
|
// Don't read or write any part of the state structure until ApplyMoves returns.
|
|
func ApplyMoves(stmts []MoveStatement, state *states.State) MoveResults {
|
|
ret := MoveResults{
|
|
Changes: make(map[addrs.UniqueKey]MoveSuccess),
|
|
Blocked: make(map[addrs.UniqueKey]MoveBlocked),
|
|
}
|
|
|
|
// The methodology here is to construct a small graph of all of the move
|
|
// statements where the edges represent where a particular statement
|
|
// is either chained from or nested inside the effect of another statement.
|
|
// That then means we can traverse the graph in topological sort order
|
|
// to gradually move objects through potentially multiple moves each.
|
|
|
|
g := buildMoveStatementGraph(stmts)
|
|
|
|
// If there are any cycles in the graph then we'll not take any action
|
|
// at all. The separate validation step should detect this and return
|
|
// an error.
|
|
if len(g.Cycles()) != 0 {
|
|
return ret
|
|
}
|
|
|
|
// The starting nodes are the ones that don't depend on any other nodes.
|
|
startNodes := make(dag.Set, len(stmts))
|
|
for _, v := range g.Vertices() {
|
|
if len(g.DownEdges(v)) == 0 {
|
|
startNodes.Add(v)
|
|
}
|
|
}
|
|
|
|
if startNodes.Len() == 0 {
|
|
log.Println("[TRACE] refactoring.ApplyMoves: No 'moved' statements to consider in this configuration")
|
|
return ret
|
|
}
|
|
|
|
log.Printf("[TRACE] refactoring.ApplyMoves: Processing 'moved' statements in the configuration\n%s", logging.Indent(g.String()))
|
|
|
|
recordOldAddr := func(oldAddr, newAddr addrs.AbsResourceInstance) {
|
|
oldAddrKey := oldAddr.UniqueKey()
|
|
newAddrKey := newAddr.UniqueKey()
|
|
if prevMove, exists := ret.Changes[oldAddrKey]; exists {
|
|
// If the old address was _already_ the result of a move then
|
|
// we'll replace that entry so that our results summarize a chain
|
|
// of moves into a single entry.
|
|
delete(ret.Changes, oldAddrKey)
|
|
oldAddr = prevMove.From
|
|
}
|
|
ret.Changes[newAddrKey] = MoveSuccess{
|
|
From: oldAddr,
|
|
To: newAddr,
|
|
}
|
|
}
|
|
recordBlockage := func(newAddr, wantedAddr addrs.AbsMoveable) {
|
|
ret.Blocked[newAddr.UniqueKey()] = MoveBlocked{
|
|
Wanted: wantedAddr,
|
|
Actual: newAddr,
|
|
}
|
|
}
|
|
|
|
g.ReverseDepthFirstWalk(startNodes, func(v dag.Vertex, depth int) error {
|
|
stmt := v.(*MoveStatement)
|
|
|
|
for _, ms := range state.Modules {
|
|
modAddr := ms.Addr
|
|
if !stmt.From.SelectsModule(modAddr) {
|
|
continue
|
|
}
|
|
|
|
// We now know that the current module is relevant but what
|
|
// we'll do with it depends on the object kind.
|
|
switch kind := stmt.ObjectKind(); kind {
|
|
case addrs.MoveEndpointModule:
|
|
// For a module endpoint we just try the module address
|
|
// directly.
|
|
if newAddr, matches := modAddr.MoveDestination(stmt.From, stmt.To); matches {
|
|
log.Printf("[TRACE] refactoring.ApplyMoves: %s has moved to %s", modAddr, newAddr)
|
|
|
|
// If we already have a module at the new address then
|
|
// we'll skip this move and let the existing object take
|
|
// priority.
|
|
if ms := state.Module(newAddr); ms != nil {
|
|
log.Printf("[WARN] Skipped moving %s to %s, because there's already another module instance at the destination", modAddr, newAddr)
|
|
recordBlockage(modAddr, newAddr)
|
|
continue
|
|
}
|
|
|
|
// We need to visit all of the resource instances in the
|
|
// module and record them individually as results.
|
|
for _, rs := range ms.Resources {
|
|
relAddr := rs.Addr.Resource
|
|
for key := range rs.Instances {
|
|
oldInst := relAddr.Instance(key).Absolute(modAddr)
|
|
newInst := relAddr.Instance(key).Absolute(newAddr)
|
|
recordOldAddr(oldInst, newInst)
|
|
}
|
|
}
|
|
|
|
state.MoveModuleInstance(modAddr, newAddr)
|
|
continue
|
|
}
|
|
case addrs.MoveEndpointResource:
|
|
// For a resource endpoint we need to search each of the
|
|
// resources and resource instances in the module.
|
|
for _, rs := range ms.Resources {
|
|
rAddr := rs.Addr
|
|
if newAddr, matches := rAddr.MoveDestination(stmt.From, stmt.To); matches {
|
|
log.Printf("[TRACE] refactoring.ApplyMoves: resource %s has moved to %s", rAddr, newAddr)
|
|
|
|
// If we already have a resource at the new address then
|
|
// we'll skip this move and let the existing object take
|
|
// priority.
|
|
if rs := state.Resource(newAddr); rs != nil {
|
|
log.Printf("[WARN] Skipped moving %s to %s, because there's already another resource at the destination", rAddr, newAddr)
|
|
recordBlockage(rAddr, newAddr)
|
|
continue
|
|
}
|
|
|
|
for key := range rs.Instances {
|
|
oldInst := rAddr.Instance(key)
|
|
newInst := newAddr.Instance(key)
|
|
recordOldAddr(oldInst, newInst)
|
|
}
|
|
state.MoveAbsResource(rAddr, newAddr)
|
|
continue
|
|
}
|
|
for key := range rs.Instances {
|
|
iAddr := rAddr.Instance(key)
|
|
if newAddr, matches := iAddr.MoveDestination(stmt.From, stmt.To); matches {
|
|
log.Printf("[TRACE] refactoring.ApplyMoves: resource instance %s has moved to %s", iAddr, newAddr)
|
|
|
|
// If we already have a resource instance at the new
|
|
// address then we'll skip this move and let the existing
|
|
// object take priority.
|
|
if is := state.ResourceInstance(newAddr); is != nil {
|
|
log.Printf("[WARN] Skipped moving %s to %s, because there's already another resource instance at the destination", iAddr, newAddr)
|
|
recordBlockage(iAddr, newAddr)
|
|
continue
|
|
}
|
|
|
|
recordOldAddr(iAddr, newAddr)
|
|
|
|
state.MoveAbsResourceInstance(iAddr, newAddr)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
panic(fmt.Sprintf("unhandled move object kind %s", kind))
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
return ret
|
|
}
|
|
|
|
// buildMoveStatementGraph constructs a dependency graph of the given move
|
|
// statements, where the nodes are all pointers to statements in the given
|
|
// slice and the edges represent either chaining or nesting relationships.
|
|
//
|
|
// buildMoveStatementGraph doesn't do any validation of the graph, so it
|
|
// may contain cycles and other sorts of invalidity.
|
|
func buildMoveStatementGraph(stmts []MoveStatement) *dag.AcyclicGraph {
|
|
g := &dag.AcyclicGraph{}
|
|
for i := range stmts {
|
|
// The graph nodes are pointers to the actual statements directly.
|
|
g.Add(&stmts[i])
|
|
}
|
|
|
|
// Now we'll add the edges representing chaining and nesting relationships.
|
|
// We assume that a reasonable configuration will have at most tens of
|
|
// move statements and thus this N*M algorithm is acceptable.
|
|
for dependerI := range stmts {
|
|
depender := &stmts[dependerI]
|
|
for dependeeI := range stmts {
|
|
if dependerI == dependeeI {
|
|
// skip comparing the statement to itself
|
|
continue
|
|
}
|
|
dependee := &stmts[dependeeI]
|
|
|
|
if statementDependsOn(depender, dependee) {
|
|
g.Connect(dag.BasicEdge(depender, dependee))
|
|
}
|
|
}
|
|
}
|
|
|
|
return g
|
|
}
|
|
|
|
// statementDependsOn returns true if statement a depends on statement b;
|
|
// i.e. statement b must be executed before statement a.
|
|
func statementDependsOn(a, b *MoveStatement) bool {
|
|
// chain-able moves are simple, as on the destination of one move could be
|
|
// equal to the source of another.
|
|
if a.From.CanChainFrom(b.To) {
|
|
return true
|
|
}
|
|
|
|
// Statement nesting in more complex, as we have 8 possible combinations to
|
|
// assess. Here we list all combinations, along with the statement which
|
|
// must be executed first when one address is nested within another.
|
|
// A.From IsNestedWithin B.From => A
|
|
// A.From IsNestedWithin B.To => B
|
|
// A.To IsNestedWithin B.From => A
|
|
// A.To IsNestedWithin B.To => B
|
|
// B.From IsNestedWithin A.From => B
|
|
// B.From IsNestedWithin A.To => A
|
|
// B.To IsNestedWithin A.From => B
|
|
// B.To IsNestedWithin A.To => A
|
|
//
|
|
// Since we are only interested in checking if A depends on B, we only need
|
|
// to check the 4 possibilities above which result in B being executed
|
|
// first.
|
|
return a.From.NestedWithin(b.To) ||
|
|
a.To.NestedWithin(b.To) ||
|
|
b.From.NestedWithin(a.From) ||
|
|
b.To.NestedWithin(a.From)
|
|
}
|
|
|
|
// MoveResults describes the outcome of an ApplyMoves call.
|
|
type MoveResults struct {
|
|
// Changes is a map from the unique keys of the final new resource
|
|
// instance addresses to an object describing what changed.
|
|
//
|
|
// This includes one entry for each resource instance address that was
|
|
// the destination of a move statement. It doesn't include resource
|
|
// instances that were not affected by moves at all, but it does include
|
|
// resource instance addresses that were "blocked" (also recorded in
|
|
// BlockedAddrs) if and only if they were able to move at least
|
|
// partially along a chain before being blocked.
|
|
//
|
|
// In the return value from ApplyMoves, all of the keys are guaranteed to
|
|
// be unique keys derived from addrs.AbsResourceInstance values.
|
|
Changes map[addrs.UniqueKey]MoveSuccess
|
|
|
|
// Blocked is a map from the unique keys of the final new
|
|
// resource instances addresses to information about where they "wanted"
|
|
// to move, but were blocked by a pre-existing object at the same address.
|
|
//
|
|
// "Blocking" can arise in unusual situations where multiple points along
|
|
// a move chain were already bound to objects, and thus only one of them
|
|
// can actually adopt the final position in the chain. It can also
|
|
// occur in other similar situations, such as if a configuration contains
|
|
// a move of an entire module and a move of an individual resource into
|
|
// that module, such that the individual resource would collide with a
|
|
// resource in the whole module that was moved.
|
|
//
|
|
// In the return value from ApplyMoves, all of the keys are guaranteed to
|
|
// be unique keys derived from values of addrs.AbsMoveable types.
|
|
Blocked map[addrs.UniqueKey]MoveBlocked
|
|
}
|
|
|
|
type MoveSuccess struct {
|
|
From addrs.AbsResourceInstance
|
|
To addrs.AbsResourceInstance
|
|
}
|
|
|
|
type MoveBlocked struct {
|
|
Wanted addrs.AbsMoveable
|
|
Actual addrs.AbsMoveable
|
|
}
|
|
|
|
// AddrMoved returns true if and only if the given resource instance moved to
|
|
// a new address in the ApplyMoves call that the receiver is describing.
|
|
//
|
|
// If AddrMoved returns true, you can pass the same address to method OldAddr
|
|
// to find its original address prior to moving.
|
|
func (rs MoveResults) AddrMoved(newAddr addrs.AbsResourceInstance) bool {
|
|
_, ok := rs.Changes[newAddr.UniqueKey()]
|
|
return ok
|
|
}
|
|
|
|
// OldAddr returns the old address of the given resource instance address, or
|
|
// just returns back the same address if the given instance wasn't affected by
|
|
// any move statements.
|
|
func (rs MoveResults) OldAddr(newAddr addrs.AbsResourceInstance) addrs.AbsResourceInstance {
|
|
change, ok := rs.Changes[newAddr.UniqueKey()]
|
|
if !ok {
|
|
return newAddr
|
|
}
|
|
return change.From
|
|
}
|