// TransformTemplate processes a template with the provided parameters, returning an error if transformation fails.
func TransformTemplate(tpl *templateapi.Template, client client.TemplateConfigsNamespacer, namespace string, parameters map[string]string) (*templateapi.Template, error) {
// only set values that match what's expected by the template.
for k, value := range parameters {
v := template.GetParameterByName(tpl, k)
if v == nil {
return nil, fmt.Errorf("unexpected parameter name %q", k)
}
v.Value = value
v.Generate = ""
template.AddParameter(tpl, *v)
}
name := localOrRemoteName(tpl.ObjectMeta, namespace)
// transform the template
result, err := client.TemplateConfigs(namespace).Create(tpl)
if err != nil {
return nil, fmt.Errorf("error processing template %s: %v", name, err)
}
// ensure the template objects are decoded
// TODO: in the future, this should be more automatic
if errs := runtime.DecodeList(result.Objects, kapi.Codecs.UniversalDecoder()); len(errs) > 0 {
err = errors.NewAggregate(errs)
return nil, fmt.Errorf("error processing template %s: %v", name, err)
}
return result, nil
}
// buildTemplates converts a set of resolved, valid references into references to template objects.
func (c *AppConfig) buildTemplates(components app.ComponentReferences, environment app.Environment) ([]runtime.Object, error) {
objects := []runtime.Object{}
for _, ref := range components {
tpl := ref.Input().ResolvedMatch.Template
glog.V(4).Infof("processing template %s/%s", c.originNamespace, tpl.Name)
for _, env := range environment.List() {
// only set environment values that match what's expected by the template.
if v := template.GetParameterByName(tpl, env.Name); v != nil {
v.Value = env.Value
v.Generate = ""
template.AddParameter(tpl, *v)
} else {
return nil, fmt.Errorf("unexpected parameter name %q", env.Name)
}
}
result, err := c.osclient.TemplateConfigs(c.originNamespace).Create(tpl)
if err != nil {
return nil, fmt.Errorf("error processing template %s/%s: %v", c.originNamespace, tpl.Name, err)
}
errs := runtime.DecodeList(result.Objects, kapi.Scheme)
if len(errs) > 0 {
err = errors.NewAggregate(errs)
return nil, fmt.Errorf("error processing template %s/%s: %v", c.originNamespace, tpl.Name, errs)
}
objects = append(objects, result.Objects...)
}
return objects, nil
}
// injectUserVars injects user specified variables into the Template
func injectUserVars(values app.Environment, t *templateapi.Template) []error {
var errors []error
for param, val := range values {
if v := template.GetParameterByName(t, param); v != nil {
v.Value = val
v.Generate = ""
} else {
errors = append(errors, fmt.Errorf("unknown parameter name %q\n", param))
}
}
return errors
}
// substituteTemplateParameters injects user specified parameter values into the Template
func substituteTemplateParameters(params map[string]string, t *templateapi.Template) []error {
var errors []error
for name, value := range params {
if len(name) == 0 {
errors = append(errors, fmt.Errorf("template parameter name cannot be empty (%q)", value))
continue
}
if v := template.GetParameterByName(t, name); v != nil {
v.Value = value
v.Generate = ""
} else {
errors = append(errors, fmt.Errorf("unknown parameter %q specified for template", name))
}
}
return errors
}
// injectUserVars injects user specified variables into the Template
func injectUserVars(values []string, out io.Writer, t *templateapi.Template) {
for _, keypair := range values {
p := strings.SplitN(keypair, "=", 2)
if len(p) != 2 {
fmt.Fprintf(out, "invalid parameter assignment in %q: %q\n", t.Name, keypair)
continue
}
if v := template.GetParameterByName(t, p[0]); v != nil {
v.Value = p[1]
v.Generate = ""
template.AddParameter(t, *v)
} else {
fmt.Fprintf(out, "unknown parameter name %q\n", p[0])
}
}
}
// injectUserVars injects user specified variables into the Template
func injectUserVars(cmd *cobra.Command, t *api.Template) {
values := kcmdutil.GetFlagStringSlice(cmd, "value")
for _, keypair := range values {
p := strings.SplitN(keypair, "=", 2)
if len(p) != 2 {
fmt.Fprintf(cmd.Out(), "invalid parameter assignment in %q: %q\n", t.Name, keypair)
continue
}
if v := template.GetParameterByName(t, p[0]); v != nil {
v.Value = p[1]
v.Generate = ""
template.AddParameter(t, *v)
} else {
fmt.Fprintf(cmd.Out(), "unknown parameter name %q\n", p[0])
}
}
}
// injectUserVars injects user specified variables into the Template
func injectUserVars(values []string, t *templateapi.Template) []error {
var errors []error
for _, keypair := range values {
p := strings.SplitN(keypair, "=", 2)
if len(p) != 2 {
errors = append(errors, fmt.Errorf("invalid parameter assignment in %q: %q\n", t.Name, keypair))
} else {
if v := template.GetParameterByName(t, p[0]); v != nil {
v.Value = p[1]
v.Generate = ""
} else {
errors = append(errors, fmt.Errorf("unknown parameter name %q\n", p[0]))
}
}
}
return errors
}
