terraform/config/import_tree.go

112 lines
2.5 KiB
Go

package config
import (
"fmt"
"io"
"path/filepath"
)
// configurable is an interface that must be implemented by any configuration
// formats of Terraform in order to return a *Config.
type configurable interface {
Config() (*Config, error)
}
// importTree is the result of the first-pass load of the configuration
// files. It is a tree of raw configurables and then any children (their
// imports).
//
// An importTree can be turned into a configTree.
type importTree struct {
Path string
Raw configurable
Children []*importTree
}
// This is the function type that must be implemented by the configuration
// file loader to turn a single file into a configurable and any additional
// imports.
type fileLoaderFunc func(path string) (configurable, []string, error)
// loadTree takes a single file and loads the entire importTree for that
// file. This function detects what kind of configuration file it is an
// executes the proper fileLoaderFunc.
func loadTree(root string) (*importTree, error) {
var f fileLoaderFunc
switch filepath.Ext(root) {
case ".tf":
f = loadFileLibucl
default:
return nil, fmt.Errorf(
"%s: unknown configuration format. Use '.tf' extension",
root)
}
c, imps, err := f(root)
if err != nil {
return nil, err
}
children := make([]*importTree, len(imps))
for i, imp := range imps {
t, err := loadTree(imp)
if err != nil {
return nil, err
}
children[i] = t
}
return &importTree{
Path: root,
Raw: c,
Children: children,
}, nil
}
// Close releases any resources we might be holding open for the importTree.
//
// This can safely be called even while ConfigTree results are alive. The
// importTree is not bound to these.
func (t *importTree) Close() error {
if c, ok := t.Raw.(io.Closer); ok {
c.Close()
}
for _, ct := range t.Children {
ct.Close()
}
return nil
}
// ConfigTree traverses the importTree and turns each node into a *Config
// object, ultimately returning a *configTree.
func (t *importTree) ConfigTree() (*configTree, error) {
config, err := t.Raw.Config()
if err != nil {
return nil, fmt.Errorf(
"Error loading %s: %s",
t.Path,
err)
}
// Build our result
result := &configTree{
Path: t.Path,
Config: config,
}
// Build the config trees for the children
result.Children = make([]*configTree, len(t.Children))
for i, ct := range t.Children {
t, err := ct.ConfigTree()
if err != nil {
return nil, err
}
result.Children[i] = t
}
return result, nil
}