Method ProcessOutputs

cft/pkg/outputs.go:20–89

processModuleOutputs looks for any references in the parent template to the module's outputs and replaces them.

()

// processModuleOutputs looks for any references in the parent
// template to the module's outputs and replaces them.
func (module *Module) ProcessOutputs() error {

	// Visit each node in the parent template. If we see a Ref, Sub, or
	// GetAtt that points to one of this module's output values,
	// Replace the reference with that value.

	if module == nil {
		return fmt.Errorf("module is nil")
	}

	if module.Config == nil {
		return fmt.Errorf("module config is nil")
	}

	if module.OutputsNode == nil {
		return nil
	}

	// Resolve output values first
	for i := 0; i < len(module.OutputsNode.Content); i += 2 {
		outputNode := module.OutputsNode.Content[i+1]
		module.Resolve(outputNode)
	}

	t := module.ParentTemplate

	// Store the Outputs node on the template for later use
	if t.ModuleOutputs == nil {
		t.ModuleOutputs = make(map[string]*yaml.Node)
	}
	t.ModuleOutputs[module.Config.Name] = module.OutputsNode

	// Iterate over module outputs
	for outputName, outputVal := range module.Outputs() {

		var err error

		// Use a visitor function to find Fn::Sub or Fn::GetAtt that points to
		// this output. Refs can't point to module outputs since you need
		// ModuleName.OutputName
		vf := func(v *visitor.Visitor) {
			n := v.GetYamlNode()
			if n.Kind != yaml.MappingNode || len(n.Content) != 2 {
				return
			}
			switch n.Content[0].Value {
			case string(cft.Sub):
				err = module.OutputSub(outputName, outputVal, n)
				if err != nil {
					v.Stop()
					return
				}
			case string(cft.GetAtt):
				err = module.OutputGetAtt(outputName, outputVal, n)
				if err != nil {
					v.Stop()
					return
				}