func main() { templateRules := template.Rules{} inputParameters := NewInputsFlag(&templateRules) var templateFilename string var outputWhat OutputWhatFlag flag.StringVar(&templateFilename, "template", "-", "CloudFormation Template to process") flag.Var(&inputParameters, "parameters", "File to use of input parameters (can be specified multiple times)") flag.Var(&outputWhat, "output", "What to output after processing the Template") flag.Parse() var jsonStream io.Reader var err error if templateFilename == "-" { jsonStream = os.Stdin } else if jsonStream, err = os.Open(templateFilename); err != nil { panic(err) } dec := json.NewDecoder(jsonStream) t := make(map[string]interface{}) if err := dec.Decode(&t); err != nil { panic(err) } sources := fallbackmap.FallbackMap{} stack := deepstack.DeepStack{} sources.Attach(inputParameters.Get()) sources.Attach(deepalias.DeepAlias{&stack}) sources.Attach(deepcloudformationoutputs.NewDeepCloudFormationOutputs("eu-west-1")) sources.Attach(deepcloudformationresources.NewDeepCloudFormationResources("eu-west-1")) stack.Push(&sources) templateRules.AttachEarly(rules.ExcludeComments) templateRules.AttachEarly(rules.MakeFnFor(&stack, &templateRules)) templateRules.AttachEarly(rules.MakeFnWith(&stack, &templateRules)) templateRules.Attach(rules.FnAdd) templateRules.Attach(rules.FnIf) templateRules.Attach(rules.FnAnd) templateRules.Attach(rules.FnOr) templateRules.Attach(rules.FnNot) templateRules.Attach(rules.FnEquals) templateRules.Attach(rules.FnConcat) templateRules.Attach(rules.FnFromEntries) templateRules.Attach(rules.FnHasKey) templateRules.Attach(rules.FnJoin) templateRules.Attach(rules.FnKeys) templateRules.Attach(rules.FnLength) templateRules.Attach(rules.FnMerge) templateRules.Attach(rules.FnMergeDeep) templateRules.Attach(rules.FnMod) templateRules.Attach(rules.FnSplit) templateRules.Attach(rules.FnToEntries) templateRules.Attach(rules.FnUnique) templateRules.Attach(rules.MakeFnGetAtt(&stack, &templateRules)) templateRules.Attach(rules.MakeRef(&stack, &templateRules)) templateRules.Attach(rules.MakeFnHasRef(&stack)) templateRules.Attach(rules.MakeFnIncludeFile(vfs.OS("/"), &templateRules)) templateRules.Attach(rules.MakeFnIncludeFileRaw(vfs.OS("/"))) templateRules.Attach(rules.ReduceConditions) // First Pass (to collect Parameter names) processed := template.Process(t, &templateRules) parameterRefs := map[string]interface{}{} if processedMap, ok := processed.(map[string]interface{}); ok { if processedParameters, ok := processedMap["Parameters"]; ok { if processedParametersMap, ok := processedParameters.(map[string]interface{}); ok { for parameterName, _ := range processedParametersMap { parameterRefs[parameterName] = map[string]interface{}{ "ParamRef": parameterName, } } } } } stack.Push(fallbackmap.DeepMap(parameterRefs)) templateRules.Attach(func(path []interface{}, node interface{}) (interface{}, interface{}) { key := interface{}(nil) if len(path) > 0 { key = path[len(path)-1] } if nodeMap, ok := node.(map[string]interface{}); !ok || len(nodeMap) != 1 { return key, node //passthru } if refName, ok := node.(map[string]interface{})["ParamRef"]; ok { return key, interface{}(map[string]interface{}{"Ref": interface{}(refName)}) } return key, node }) processed = template.Process(t, &templateRules) stack.PopDiscard() switch outputWhat.Get().what { case OutputTemplate: enc := json.NewEncoder(os.Stdout) enc.Encode(processed) case OutputCredentials: credentials := []interface{}{} credentialMap := make(map[string]interface{}) for _, input := range inputParameters.Sources() { if !outputWhat.Get().hasKey || outputWhat.Get().key == input.filename { credentialMap = template.Process(input.data, &templateRules).(map[string]interface{}) credentialMap["$comment"] = map[string]interface{}{"filename": input.filename} credentials = append(credentials, credentialMap) } } if len(credentials) == 0 && outputWhat.Get().hasKey { panic(fmt.Errorf("No parameters file '%s' was input", outputWhat.Get().key)) } enc := json.NewEncoder(os.Stdout) if len(credentials) == 1 { enc.Encode(credentials[0]) } else { enc.Encode(credentials) } case OutputParameters: parameters := []cloudformation.Parameter{} for name, _ := range parameterRefs { value, ok := sources.Get([]string{name}) if !ok { continue } value = template.Process(value, &templateRules) parameters = append(parameters, func(name string, value interface{}) cloudformation.Parameter { stringval := fmt.Sprintf("%s", value) boolval := false return cloudformation.Parameter{ ParameterKey: &name, ParameterValue: &stringval, UsePreviousValue: &boolval, } }(name, value)) } enc := json.NewEncoder(os.Stdout) enc.Encode(parameters) } }