2016-04-28 11:46:46 +02:00
|
|
|
package terraform
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
)
|
|
|
|
|
|
|
|
// ImportStateTransformer is a GraphTransformer that adds nodes to the
|
|
|
|
// graph to represent the imports we want to do for resources.
|
|
|
|
type ImportStateTransformer struct {
|
|
|
|
Targets []*ImportTarget
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *ImportStateTransformer) Transform(g *Graph) error {
|
|
|
|
nodes := make([]*graphNodeImportState, 0, len(t.Targets))
|
|
|
|
for _, target := range t.Targets {
|
|
|
|
addr, err := ParseResourceAddress(target.Addr)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf(
|
|
|
|
"failed to parse resource address '%s': %s",
|
|
|
|
target.Addr, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
nodes = append(nodes, &graphNodeImportState{
|
|
|
|
Addr: addr,
|
|
|
|
ID: target.ID,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build the graph vertices
|
|
|
|
for _, n := range nodes {
|
|
|
|
g.Add(n)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type graphNodeImportState struct {
|
|
|
|
Addr *ResourceAddress // Addr is the resource address to import to
|
|
|
|
ID string // ID is the ID to import as
|
2016-04-28 19:18:19 +02:00
|
|
|
|
|
|
|
states []*InstanceState
|
2016-04-28 11:46:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (n *graphNodeImportState) Name() string {
|
2016-04-30 07:09:34 +02:00
|
|
|
return fmt.Sprintf("%s (import id: %s)", n.Addr, n.ID)
|
2016-04-28 11:46:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (n *graphNodeImportState) ProvidedBy() []string {
|
|
|
|
return []string{resourceProvider(n.Addr.Type, "")}
|
|
|
|
}
|
|
|
|
|
|
|
|
// GraphNodeSubPath
|
|
|
|
func (n *graphNodeImportState) Path() []string {
|
2016-04-30 08:28:58 +02:00
|
|
|
return normalizeModulePath(n.Addr.Path)
|
2016-04-28 11:46:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// GraphNodeEvalable impl.
|
|
|
|
func (n *graphNodeImportState) EvalTree() EvalNode {
|
|
|
|
var provider ResourceProvider
|
|
|
|
info := &InstanceInfo{
|
2016-05-04 21:40:45 +02:00
|
|
|
Id: fmt.Sprintf("%s.%s", n.Addr.Type, n.Addr.Name),
|
2016-04-30 08:28:58 +02:00
|
|
|
ModulePath: n.Path(),
|
2016-04-28 11:46:46 +02:00
|
|
|
Type: n.Addr.Type,
|
|
|
|
}
|
|
|
|
|
2016-04-28 19:18:19 +02:00
|
|
|
// Reset our states
|
|
|
|
n.states = nil
|
|
|
|
|
|
|
|
// Return our sequence
|
2016-04-28 11:46:46 +02:00
|
|
|
return &EvalSequence{
|
|
|
|
Nodes: []EvalNode{
|
|
|
|
&EvalGetProvider{
|
|
|
|
Name: n.ProvidedBy()[0],
|
|
|
|
Output: &provider,
|
|
|
|
},
|
|
|
|
&EvalImportState{
|
|
|
|
Provider: &provider,
|
|
|
|
Info: info,
|
2016-05-04 21:40:45 +02:00
|
|
|
Id: n.ID,
|
2016-04-28 19:18:19 +02:00
|
|
|
Output: &n.states,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// GraphNodeDynamicExpandable impl.
|
|
|
|
//
|
|
|
|
// We use DynamicExpand as a way to generate the subgraph of refreshes
|
|
|
|
// and state inserts we need to do for our import state. Since they're new
|
|
|
|
// resources they don't depend on anything else and refreshes are isolated
|
|
|
|
// so this is nearly a perfect use case for dynamic expand.
|
|
|
|
func (n *graphNodeImportState) DynamicExpand(ctx EvalContext) (*Graph, error) {
|
|
|
|
g := &Graph{Path: ctx.Path()}
|
|
|
|
|
2016-05-01 00:29:03 +02:00
|
|
|
// nameCounter is used to de-dup names in the state.
|
|
|
|
nameCounter := make(map[string]int)
|
|
|
|
|
|
|
|
// Compile the list of addresses that we'll be inserting into the state.
|
|
|
|
// We do this ahead of time so we can verify that we aren't importing
|
|
|
|
// something that already exists.
|
|
|
|
addrs := make([]*ResourceAddress, len(n.states))
|
|
|
|
for i, state := range n.states {
|
|
|
|
addr := *n.Addr
|
|
|
|
if t := state.Ephemeral.Type; t != "" {
|
|
|
|
addr.Type = t
|
|
|
|
}
|
|
|
|
|
|
|
|
// Determine if we need to suffix the name to de-dup
|
|
|
|
key := addr.String()
|
|
|
|
count, ok := nameCounter[key]
|
|
|
|
if ok {
|
|
|
|
count++
|
|
|
|
addr.Name += fmt.Sprintf("-%d", count)
|
|
|
|
}
|
|
|
|
nameCounter[key] = count
|
|
|
|
|
|
|
|
// Add it to our list
|
|
|
|
addrs[i] = &addr
|
|
|
|
}
|
|
|
|
|
2016-05-01 00:53:48 +02:00
|
|
|
// Verify that all the addresses are clear
|
|
|
|
state, lock := ctx.State()
|
|
|
|
lock.RLock()
|
|
|
|
defer lock.RUnlock()
|
|
|
|
filter := &StateFilter{State: state}
|
|
|
|
for _, addr := range addrs {
|
|
|
|
result, err := filter.Filter(addr.String())
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("Error verifying address %s: %s", addr, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Go through the filter results and it is an error if we find
|
|
|
|
// a matching InstanceState, meaning that we would have a collision.
|
|
|
|
for _, r := range result {
|
|
|
|
if _, ok := r.Value.(*InstanceState); ok {
|
|
|
|
return nil, fmt.Errorf(
|
|
|
|
"Can't import %s, would collide with an existing resource.\n\n"+
|
|
|
|
"Please remove or rename this resource before continuing.",
|
|
|
|
addr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 19:18:19 +02:00
|
|
|
// For each of the states, we add a node to handle the refresh/add to state.
|
|
|
|
// "n.states" is populated by our own EvalTree with the result of
|
|
|
|
// ImportState. Since DynamicExpand is always called after EvalTree, this
|
|
|
|
// is safe.
|
2016-05-01 00:29:03 +02:00
|
|
|
for i, state := range n.states {
|
2016-04-28 19:18:19 +02:00
|
|
|
g.Add(&graphNodeImportStateSub{
|
2016-05-01 00:29:03 +02:00
|
|
|
Target: addrs[i],
|
2016-04-28 19:25:58 +02:00
|
|
|
Path_: n.Path(),
|
|
|
|
State: state,
|
2016-04-28 19:18:19 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Root transform for a single root
|
|
|
|
t := &RootTransformer{}
|
|
|
|
if err := t.Transform(g); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Done!
|
|
|
|
return g, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// graphNodeImportStateSub is the sub-node of graphNodeImportState
|
|
|
|
// and is part of the subgraph. This node is responsible for refreshing
|
|
|
|
// and adding a resource to the state once it is imported.
|
|
|
|
type graphNodeImportStateSub struct {
|
|
|
|
Target *ResourceAddress
|
|
|
|
State *InstanceState
|
|
|
|
Path_ []string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (n *graphNodeImportStateSub) Name() string {
|
|
|
|
return fmt.Sprintf("import %s result: %s", n.Target, n.State.ID)
|
|
|
|
}
|
|
|
|
|
2016-04-30 08:28:58 +02:00
|
|
|
func (n *graphNodeImportStateSub) Path() []string {
|
|
|
|
return n.Path_
|
|
|
|
}
|
|
|
|
|
2016-04-28 19:18:19 +02:00
|
|
|
// GraphNodeEvalable impl.
|
|
|
|
func (n *graphNodeImportStateSub) EvalTree() EvalNode {
|
|
|
|
// If the Ephemeral type isn't set, then it is an error
|
|
|
|
if n.State.Ephemeral.Type == "" {
|
|
|
|
err := fmt.Errorf(
|
|
|
|
"import of %s didn't set type for %s",
|
|
|
|
n.Target.String(), n.State.ID)
|
|
|
|
return &EvalReturnError{Error: &err}
|
|
|
|
}
|
|
|
|
|
|
|
|
// DeepCopy so we're only modifying our local copy
|
|
|
|
state := n.State.DeepCopy()
|
|
|
|
|
|
|
|
// Build the resource info
|
|
|
|
info := &InstanceInfo{
|
2016-05-09 22:39:34 +02:00
|
|
|
Id: fmt.Sprintf("%s.%s", n.Target.Type, n.Target.Name),
|
2016-04-28 19:18:19 +02:00
|
|
|
ModulePath: n.Path_,
|
|
|
|
Type: n.State.Ephemeral.Type,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Key is the resource key
|
|
|
|
key := &ResourceStateKey{
|
|
|
|
Name: n.Target.Name,
|
|
|
|
Type: info.Type,
|
|
|
|
Index: -1,
|
|
|
|
}
|
|
|
|
|
|
|
|
// The eval sequence
|
|
|
|
var provider ResourceProvider
|
|
|
|
return &EvalSequence{
|
|
|
|
Nodes: []EvalNode{
|
|
|
|
&EvalGetProvider{
|
|
|
|
Name: resourceProvider(info.Type, ""),
|
|
|
|
Output: &provider,
|
|
|
|
},
|
|
|
|
&EvalRefresh{
|
|
|
|
Provider: &provider,
|
|
|
|
State: &state,
|
|
|
|
Info: info,
|
2016-04-28 19:25:58 +02:00
|
|
|
Output: &state,
|
2016-04-28 19:18:19 +02:00
|
|
|
},
|
2016-05-09 22:39:34 +02:00
|
|
|
&EvalImportStateVerify{
|
|
|
|
Info: info,
|
|
|
|
Id: n.State.ID,
|
|
|
|
State: &state,
|
|
|
|
},
|
2016-04-28 19:18:19 +02:00
|
|
|
&EvalWriteState{
|
|
|
|
Name: key.String(),
|
|
|
|
ResourceType: info.Type,
|
|
|
|
Provider: resourceProvider(info.Type, ""),
|
|
|
|
State: &state,
|
2016-04-28 11:46:46 +02:00
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|