func loadTemplate(args []string) *common.Template {
var template *common.Template
var err error
if len(args) < 2 {
fmt.Fprintln(os.Stderr, "No template name or configuration(s) supplied")
usage()
}
if len(args) < 3 {
if t := getRegistryType(args[1]); t != nil {
template = buildTemplateFromType(*t)
} else {
template, err = expander.NewTemplateFromRootTemplate(args[1])
}
} else {
template, err = expander.NewTemplateFromFileNames(args[1], args[2:])
}
if err != nil {
log.Fatalf("cannot create configuration from supplied arguments: %s\n", err)
}
// Override name if set from flags.
if *deployment_name != "" {
template.Name = *deployment_name
}
return template
}
// ExpandTemplate expands the supplied template, and returns a configuration.
// It will also update the imports in the provided template if any were added
// during type resolution.
func (e *expander) ExpandTemplate(t *common.Template) (*ExpandedTemplate, error) {
// We have a fencepost problem here.
// 1. Start by trying to resolve any missing templates
// 2. Expand the configuration using all the of the imports available to us at this point
// 3. Expansion may yield additional templates, so we run the type resolution again
// 4. If type resolution resulted in new imports being available, return to 2.
config := &common.Configuration{}
if err := yaml.Unmarshal([]byte(t.Content), config); err != nil {
e := fmt.Errorf("Unable to unmarshal configuration (%s): %s", err, t.Content)
return nil, e
}
var finalLayout *common.Layout
needResolve := map[string]*common.LayoutResource{}
// Start things off by attempting to resolve the templates in a first pass.
newImp, err := e.typeResolver.ResolveTypes(config, t.Imports)
if err != nil {
e := fmt.Errorf("type resolution failed: %s", err)
return nil, expanderError(t, e)
}
t.Imports = append(t.Imports, newImp...)
for {
// Now expand with everything imported.
result, err := e.expandTemplate(t)
if err != nil {
e := fmt.Errorf("template expansion: %s", err)
return nil, expanderError(t, e)
}
// Once we set this layout, we're operating on the "needResolve" *LayoutResources,
// which are pointers into the original layout structure. After each expansion we
// lose the templates in the previous expansion, so we have to keep the first one
// around and keep appending to the pointers in it as we get more layers of expansion.
if finalLayout == nil {
finalLayout = result.Layout
}
needResolve = walkLayout(result.Layout, t.Imports, needResolve)
newImp, err = e.typeResolver.ResolveTypes(result.Config, t.Imports)
if err != nil {
e := fmt.Errorf("type resolution failed: %s", err)
return nil, expanderError(t, e)
}
// If the new imports contain nothing, we are done. Everything is fully expanded.
if len(newImp) == 0 {
result.Layout = finalLayout
return result, nil
}
// Update imports with any new imports from type resolution.
t.Imports = append(t.Imports, newImp...)
}
}
func loadTemplate(args []string) *common.Template {
var template *common.Template
var err error
if len(args) < 2 {
fmt.Fprintln(os.Stderr, "No template name or configuration(s) supplied")
usage()
}
if *stdin {
if len(args) < 2 {
usage()
}
input, err := ioutil.ReadAll(os.Stdin)
if err != nil {
panic(err)
}
r := bytes.NewReader(input)
template, err = expander.NewTemplateFromArchive(args[1], r, args[2:])
if err != nil {
if err != tar.ErrHeader {
panic(err)
}
r := bytes.NewReader(input)
template, err = expander.NewTemplateFromReader(args[1], r, args[2:])
if err != nil {
panic(fmt.Errorf("cannot create configuration from supplied arguments: %s\n", err))
}
}
} else {
// See if the first argument is a local file. It could either be a type, or it could be a configuration. If
// it's a local file, it's configuration.
if _, err := os.Stat(args[1]); err == nil {
if len(args) > 2 {
template, err = expander.NewTemplateFromFileNames(args[1], args[2:])
} else {
template, err = expander.NewTemplateFromRootTemplate(args[1])
}
} else {
template = buildTemplateFromType(args[1])
}
if err != nil {
panic(fmt.Errorf("cannot create configuration from supplied arguments: %s\n", err))
}
}
// Override name if set from flags.
if *deployment_name != "" {
template.Name = *deployment_name
}
return template
}
func loadTemplate(args []string) *common.Template {
var template *common.Template
var err error
if len(args) < 2 {
fmt.Fprintln(os.Stderr, "No template name or configuration(s) supplied")
usage()
}
if *stdin {
if len(args) < 2 {
usage()
}
input, err := ioutil.ReadAll(os.Stdin)
if err != nil {
panic(err)
}
r := bytes.NewReader(input)
template, err = expander.NewTemplateFromArchive(args[1], r, args[2:])
if err != nil {
if err != tar.ErrHeader {
panic(err)
}
r := bytes.NewReader(input)
template, err = expander.NewTemplateFromReader(args[1], r, args[2:])
if err != nil {
panic(fmt.Errorf("cannot create configuration from supplied arguments: %s\n", err))
}
}
} else {
if len(args) < 3 {
if t := getRegistryType(args[1]); t != nil {
template = buildTemplateFromType(*t)
} else {
template, err = expander.NewTemplateFromRootTemplate(args[1])
}
} else {
template, err = expander.NewTemplateFromFileNames(args[1], args[2:])
}
if err != nil {
panic(fmt.Errorf("cannot create configuration from supplied arguments: %s\n", err))
}
}
// Override name if set from flags.
if *deployment_name != "" {
template.Name = *deployment_name
}
return template
}