func autoConvert_v1_Template_To_api_Template(in *Template, out *template_api.Template, s conversion.Scope) error { if err := api.Convert_unversioned_TypeMeta_To_unversioned_TypeMeta(&in.TypeMeta, &out.TypeMeta, s); err != nil { return err } if err := api_v1.Convert_v1_ObjectMeta_To_api_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil { return err } out.Message = in.Message if in.Objects != nil { in, out := &in.Objects, &out.Objects *out = make([]runtime.Object, len(*in)) for i := range *in { if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&(*in)[i], &(*out)[i], s); err != nil { return err } } } else { out.Objects = nil } if in.Parameters != nil { in, out := &in.Parameters, &out.Parameters *out = make([]template_api.Parameter, len(*in)) for i := range *in { if err := Convert_v1_Parameter_To_api_Parameter(&(*in)[i], &(*out)[i], s); err != nil { return err } } } else { out.Parameters = nil } out.ObjectLabels = in.ObjectLabels return nil }
// Process transforms Template object into List object. It generates // Parameter values using the defined set of generators first, and then it // substitutes all Parameter expression occurrences with their corresponding // values (currently in the containers' Environment variables only). func (p *Processor) Process(template *api.Template) field.ErrorList { templateErrors := field.ErrorList{} if fieldError := p.GenerateParameterValues(template); fieldError != nil { return append(templateErrors, fieldError) } // Place parameters into a map for efficient lookup paramMap := make(map[string]api.Parameter) for _, param := range template.Parameters { paramMap[param.Name] = param } // Perform parameter substitution on the template's user message. This can be used to // instruct a user on next steps for the template. template.Message = p.EvaluateParameterSubstitution(paramMap, template.Message) itemPath := field.NewPath("item") for i, item := range template.Objects { idxPath := itemPath.Index(i) if obj, ok := item.(*runtime.Unknown); ok { // TODO: use runtime.DecodeList when it returns ValidationErrorList decodedObj, err := runtime.Decode(runtime.UnstructuredJSONScheme, obj.Raw) if err != nil { templateErrors = append(templateErrors, field.Invalid(idxPath.Child("objects"), obj, fmt.Sprintf("unable to handle object: %v", err))) continue } item = decodedObj } newItem, err := p.SubstituteParameters(paramMap, item) if err != nil { templateErrors = append(templateErrors, field.Invalid(idxPath.Child("parameters"), template.Parameters, err.Error())) } // If an object definition's metadata includes a namespace field, the field will be stripped out of // the definition during template instantiation. This is necessary because all objects created during // instantiation are placed into the target namespace, so it would be invalid for the object to declare //a different namespace. stripNamespace(newItem) if err := util.AddObjectLabels(newItem, template.ObjectLabels); err != nil { templateErrors = append(templateErrors, field.Invalid(idxPath.Child("labels"), template.ObjectLabels, fmt.Sprintf("label could not be applied: %v", err))) } template.Objects[i] = newItem } return templateErrors }