cfhighlander 0.2.1.alpha.34 → 0.2.1.alpha.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57345cb7494a630f82ccc0be2eab077f1362a5d5bf3bea22619ad17e43f7297c
-  data.tar.gz: aefc4bebf4b709dd299c5f7a79c266674a4697f9ef64bd1b87d11ea0c031ec30
+  metadata.gz: b0076c7a6d8d8d5dcfe21a9c57601f659014cc64dadfc78c890b78ac98aaee7e
+  data.tar.gz: d9688f728ef4edd875f8603b8733c153a95270a1650b0555a706cf9d0f7f5a6b
 SHA512:
-  metadata.gz: cea97fa74dcf7bec3d87d559499a674cc1a4546502c7a14f589f6bbfef73dbe74a1f8d2ebb21d7f0ee69438fd35b222590d01f3e35d95e922430ea2d2f09ccc0
-  data.tar.gz: d16b3eaab44a8a08754768106de95c7d412c8a449902f4ca9279e536422f164c9667deb95f74fcb5c012f4b34e8a2a46bdc435cfe6db9ead84830c89fb3b702b
+  metadata.gz: 928880bc75f3bc9665ab84c7bbd8d50fe8e310d520365e065c1c036cbdc8c67195e37059e608e4340dd018943965f322361287a057a3450771905997648960ad
+  data.tar.gz: 7ba9c66b2e655044c62c7b6db12d42451e46e5c5239206b879b1951a69472c1fe883b491efbfdcd26fb38a850663abcf7e673150bdf61ec5e5ed85d383c3c490

data/README.md

@@ -5,20 +5,23 @@
 Cfhighlander is DSL processor that enables composition and orchestration of Amazon CloudFormation templates 
 written using [CfnDsl](https://github.com/cfndsl/cfndsl) in an abstract way. It tries to tackle problem of merging multiple templates into master
 template in an elegant way, so higher degree of template reuse can be achieved. It does so by formalising commonly
-used patterns via DSL statements. For an example, passing output of one stack into other stack is achieved using 
-`OutputParam` highlander DSL statement, rather than wiring this parameters manually in cfndsl templates. For this example to 
+used cfndsl template composition patterns via DSL statements. For an example, passing output of one stack into other stack is done
+automatically if parameter and output names are the same, 
+rather than wiring them manually in 'master' cfndsl template. For this example to 
 work, parent component will have to pull in both component rendering output values, and component pulling them in
-as parameters. It also enables it's user to build component library, where components can be distributed to s3, and 
-consequentially references to them resolved. 
+as parameters. Cfhighlander allows for greater reuse of component templates by allowing references to templates
+via git urls, and s3 urls. [Theonestack](https://github.com/theonestack) has several prebuilt component templates to use,
+with repositories from this org being one of the default sources for searching component templates.
 
-Highlander DSL produces CloudFormation templates in 3 phases
+Highlander DSL produces CloudFormation templates in 4 phases
 
 - Processing referenced component's configuration and resolving configuration exports
+- Wiring parameters from components to their inner components
 - Producing [CfnDsl](https://github.com/cfndsl/cfndsl) templates for all components and subcomponents as intermediary
   step
 - Producing resulting CloudFormation templates using configuration and templates generated in two previous phases.
 
-Each phase above is executable as stand-alone through CLI, making development of Highlander templates easier by enabling
+Each phase (aside from parameter wiring) above is executable as stand-alone through CLI, making development of Highlander templates easier by enabling
 debugging of produced configuration and cfndsl templates. 
 
 
@@ -169,7 +172,7 @@ This configuration level overrides component's own config file.
 - Outer component explicit configuration. You can pass `config` named parameter to `Component` statement, such as
 
 ```ruby
-HighlanderComponent do
+CfhighlanderTemplate do
 
 # ...
 # some dsl code
@@ -257,7 +260,7 @@ Parameters block is used to define CloudFormation template parameters, and metad
 are wired with outer or sibling components. 
 
 ```ruby
-HighlanderComponent do
+CfhighlanderTemplate do
   Parameters do
     ##
     ##  parameter definitions here
@@ -270,81 +273,117 @@ Parameter block supports following parameters
 
 #### ComponentParam
 
-`ComponentParam` - Component parameter takes name and default value. It defines component parameter
-that is not auto-wired in any way with outer component. This parameter will either use default value, or value
-explicitly passed from outer component. 
+`ComponentParam` - Component parameter exposes parameter to be wired from outer component. Cfhighlander's
+autowiring mechanism will try and find any stack outputs from other components defined by outer components with name 
+matching. If there is no explicit value provided, or autowired from outputs, parameter will be propagated to outer component.
+
+Propagated parameter will be prefixed with component name **if it is not defined as global parameter**. Otherwise, 
+parameter name is kept in full. 
+
+Example below demonstrates 3 different ways of providing parameter values from outer to inner component. 
+
+- Provide value explicitly
+- Provide value explicitly as output of another component     
+- Autowire value from output of another component with the same name
+- Propagate parameter to outer component 
 
 ```ruby
 
-# Inner Component
-HighlanderComponent do
+# Inner Component 1
+CfhighlanderTemplate do
   Name 's3'
   Parameters do
      ComponentParam 'BucketName','highlander.example.com.au'
+     ComponentParam 'BucketName2',''
+     ComponentParam 'BucketName3',''
+     ComponentParam 'BucketName4','', isGlobal: false # default value is false
+     ComponentParam 'BucketName5','', isGlobal: true
   end
+
 end
+
 ```
 
 ```ruby
-# Outer component
-HighlanderComponent do
-  # instantiate inner component with name and template
-  Component template:'s3',
-            name:'s3', 
-            parameters:{'BucketName' => 'outer.example.com.au'}
+# Inner Component 2
+CfhighlanderTemplate do
+  Name 'nameproducer'
+
+  # has output 'bucket name defined in cfdnsl
 end
-```
 
-#### StackParam
 
-`StackParam` - Stack parameter bubbles up to it's outer component. Outer component will either define top level parameter
-with same name as inner component parameter (if parameter is defined as global), or it will be prefixed with inner component name.
+# -- contents of cfndsl 
+CloudFormation do
 
+    Condition 'AlwaysFalse', FnEquals('true','false')
+    S3_Bucket :resourcetovalidateproperly do
+      Condition 'AlwaysFalse'
+    end
 
-```ruby
-# Outer component
-HighlanderComponent do
-  Component template:'s3',name:'s3' 
+    Output('BucketName') do
+        Value('highlanderbucketautowired.example.com.au')
+    end
 end
+
+
 ```
 
 ```ruby
-# Inner component
-HighlanderComponent do
-  Name 's3'
-  Parameters do
-    StackParam 'EnvironmentName','dev', isGlobal:true
-    StackParam 'BucketName','highlander.example.com.au', isGlobal:false
-  end
+# Outer component
+CfhighlanderTemplate do
+    Component 'nameproducer'
+    Component 's3' do
+      parameter name: 'BucketName2', value: 'nameproducer.BucketName'
+      parameter name: 'BucketName3', value: 'mybucket.example.cfhighlander.org'
+    end
 end
+
 ```
 
 
-Example above translates to following cfndsl template in outer component
+Example above translates to following wiring of parameters in cfndsl template
 ```ruby
 CloudFormation do
 
-    Parameter('EnvironmentName') do
-    Type 'String'
-    Default ''
-    end
-
-    Parameter('s3BucketName') do
-    Type 'String'
-    Default 'highlander.example.com.au'
+     # Parameter that was propagated
+    Parameter('s3BucketName4') do
+      Type 'String'
+      Default ''
+      NoEcho false
     end
-  
-    CloudFormation_Stack('s3') do
-      TemplateURL 'https://distributionbucket/dist/latest/s3.yaml'
-      Parameters ({
-      
-        'EnvironmentName' => Ref('EnvironmentName'),
-      
-        'BucketName' => Ref('s3BucketName'),
-      
-      })
+    
+    Parameter('BucketName5') do
+      Type 'String'
+      Default ''
+      NoEcho false
     end
+
+   CloudFormation_Stack('s3') do
+       TemplateURL './s3.compiled.yaml'
+       Parameters ({
+       
+          # Paramater that was auto-wired
+           'BucketName' => {"Fn::GetAtt":["nameproducer","Outputs.BucketName"]},
+       
+          # Parameter that was explicitly wired as output param from another component
+           'BucketName2' => {"Fn::GetAtt":["nameproducer","Outputs.BucketName"]},
+       
+          # Paramater that was explicitly provided
+           'BucketName3' => 'mybucket.example.cfhighlander.org',
+       
+          # Reference to parameter that was propagated. isGlobal: false when defining
+          # parameter, so parameter name is prefixed with component name 
+           'BucketName4' => {"Ref":"s3BucketName4"},
+          
+          # Reference to parameter that was propagated. isGlobal: true when defining
+          # parameter, so parameter name is not prefixed, but rather propagated as-is
+          'BucketName5' => {"Ref":"BucketName5"},
+       
+       })
+   end
 end
+
 ```
 
 
@@ -358,7 +397,7 @@ This DSL statements takes a full body, as Mapping name, Map key, and value key n
  
  ```ruby
 # Inner component
-HighlanderComponent do
+CfhighlanderTemplate do
   Name 's3'
   Parameters do
     MappingParam 'BucketName' do
@@ -370,17 +409,13 @@ end
  ```
 
 
-#### OutputParam
-
-TBD
-
 ### DependsOn
 
 `DependsOn` - this will include any globally exported libraries from given 
 template. E.g.
 
  ```ruby
-HighlanderComponent do
+CfhighlanderTemplate do
   Name 's3'
   DependsOn 'vpc@1.0.3'
 end
@@ -398,7 +433,46 @@ so extension methods can be consumed within cfndsl template.
 #### Referencing
 
 
-## Finding and loading components
+## Finding templates and creating components
+
+
+Templates are located by default in following locations
+
+- `$WD`
+- `$WD/$componentname`
+- `$WD/components/$componentname`
+- `~/.cfhighlander/components/componentname/componentversion`
+- `https://github.com/cfhighlander/theonestack/hl-component-$componentname` on `master` branch
+
+Location of component templates can be given as git/github repo:
+
+```ruby
+
+CfhighlanderTemplate do
+
+      # pulls directly from master branch of https://github.com/theonestack/hl-component-vpc
+      Component name: 'vpc0', template: 'vpc'
+    
+      # specify branch github.com: or github: work. You specify branch with hash
+      Component name: 'vpc1', template: 'github:theonestack/hl-component-vpc#master'
+    
+      # you can use git over ssh
+      # Component name: 'vpc2', template: 'git:git@github.com:theonestack/hl-component-vpc.git'
+    
+      # use git over https
+      Component name: 'vpc3', template: 'git:https://github.com/theonestack/hl-component-sns.git'
+    
+      # specify .snapshot to always clone fresh copy
+      Component name: 'vpc4', template: 'git:https://github.com/theonestack/hl-component-sns.git#master.snapshot'
+    
+      # by default, if not found locally, highlander will search for https://github.com/theonestack/component-$componentname
+      # in v${version} branch (or tag for that matter)
+      Component name: 'vpc5', template: 'vpc@1.0.4'
+
+end
+
+```
+
 
 ## Rendering CloudFormation templates
 

data/lib/cfhighlander.compiler.rb

@@ -43,13 +43,15 @@ module Cfhighlander
         @lambdas_processed = false
         @silent_mode = false
         @lambda_src_paths = []
+        @config_yaml_path = nil
+        @cfn_model = nil
 
         if @@global_extensions_paths.empty?
           global_extensions_folder = "#{File.dirname(__FILE__)}/../cfndsl_ext"
           Dir["#{global_extensions_folder}/*.rb"].each { |f| @@global_extensions_paths << f }
         end
 
-        @component.highlander_dsl.components.each do |sub_component|
+        @component.highlander_dsl.subcomponents.each do |sub_component|
           sub_component_compiler = Cfhighlander::Compiler::ComponentCompiler.new(sub_component.component_loaded)
           sub_component_compiler.component_name = sub_component.name
           @sub_components << sub_component_compiler
@@ -67,7 +69,7 @@ module Cfhighlander
         dsl = @component.highlander_dsl
         component_cfndsl = @component.cfndsl_content
 
-        @component.highlander_dsl.components.each { |sc|
+        @component.highlander_dsl.subcomponents.each { |sc|
           sc.distribution_format = out_format
         }
 
@@ -100,33 +102,38 @@ module Cfhighlander
 
       end
 
-      def compileCloudFormation(format = 'yaml')
-
-
+      def evaluateCloudFormation(format = 'yaml')
         #compile cfndsl templates first
         compileCfnDsl format unless @cfndsl_compiled
 
+        # write config
+        cfndsl_opts = []
+        cfndsl_opts.push([:yaml, @config_yaml_path])
+
+        # grab cfndsl model
+        model = CfnDsl.eval_file_with_extras(@cfndsl_compiled_path, cfndsl_opts, false)
+        @cfn_model = model
+        return model
+      end
+
+      def compileCloudFormation(format = 'yaml')
+
         dsl = @component.highlander_dsl
-        component_cfndsl = @component.cfndsl_content
 
         # create out dir if not there
         @cfn_output_location = "#{@workdir}/out/#{format}"
         output_dir = @cfn_output_location
         FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
 
-        # write config
-        config_yaml_path = writeConfig
-
 
         # compile templates
-        output_path = "#{output_dir}/#{component_name}.compiled.#{format}"
+        output_path = "#{output_dir}/#{@component_name}.compiled.#{format}"
         @cfn_template_paths << output_path
         # configure cfndsl
-        cfndsl_opts = []
-        cfndsl_opts.push([:yaml, config_yaml_path])
+
 
         # grab cfndsl model
-        model = CfnDsl.eval_file_with_extras(@cfndsl_compiled_path, cfndsl_opts, false)
+        model = evaluateCloudFormation
 
         # write resulting cloud formation template
         if format == 'json'
@@ -165,7 +172,8 @@ module Cfhighlander
           end
         end
         @config_written = true
-        config_yaml_path
+        @config_yaml_path = config_yaml_path
+        return @config_yaml_path
       end
 
       def processLambdas()

data/lib/cfhighlander.dsl.params.rb

@@ -3,6 +3,8 @@ require_relative './cfhighlander.dsl.base'
 module Cfhighlander
 
   module Dsl
+
+    # dsl statements
     class Parameters < DslBase
 
       attr_accessor :param_list
@@ -12,7 +14,7 @@ module Cfhighlander
       end
 
       def addParam(param)
-        existing_param = @param_list.find { |p| p.name == param.name }
+        existing_param = @param_list.find {|p| p.name == param.name}
         if not existing_param.nil?
           puts "Parameter being overwritten. Updating parameter #{param.name} with new definition..."
           @param_list[@param_list.index(existing_param)] = param
@@ -21,62 +23,55 @@ module Cfhighlander
         end
       end
 
-      def StackParam(name, defaultValue='', isGlobal: false, noEcho: false)
-        param = StackParam.new(name, 'String', defaultValue)
-        param.is_global = isGlobal
-        param.config = @config
-        param.no_echo = noEcho
-        addParam param
+      def StackParam(name, defaultValue = '', isGlobal: false, noEcho: false, type: 'String')
+        STDERR.puts "DEPRECATED: StackParam #{name} - Use ComponentParam instead"
+        ComponentParam(name, defaultValue, isGlobal: isGlobal, noEcho: noEcho, type: type)
+      end
+
+      def OutputParam(component:, name:, isGlobal: false, noEcho: false, type: 'String')
+        STDERR.puts ("DEPRECATED: OutputParam #{name} - Use ComponentParam instead. Outputut params are " +
+            "autorwired by name only, with component disregarded")
+        param = ComponentParam(name, '', isGlobal: isGlobal, noEcho: noEcho, type: type)
+        param.provided_value = "#{component}.#{name}"
       end
 
-      def ComponentParam(name, defaultValue='')
-        param = ComponentParam.new(name, 'String', defaultValue)
+      def ComponentParam(name, defaultValue = '', isGlobal: false, noEcho: false, type: 'String', allowedValues: nil)
+        param = Parameter.new(name, type, defaultValue, noEcho, isGlobal, allowedValues)
         param.config = @config
         addParam param
+        return param
       end
 
-      def MappingParam(name, defaultValue='', &block)
+      def MappingParam(name, defaultValue = '', &block)
         param = MappingParam.new(name, 'String', defaultValue)
         param.config = @config
         param.instance_eval(&block)
         addParam param
       end
 
-      def OutputParam(component:, name:, default: '')
-        param = OutputParam.new(component, name, default)
-        param.config = @config
-        addParam param
-      end
+
     end
 
+    # model classes
     class Parameter < DslBase
-      attr_accessor :name, :type, :default_value, :no_echo
-
-      def initialize(name, type, defaultValue, noEcho = false)
+      attr_accessor :name,
+          :type,
+          :default_value,
+          :no_echo,
+          :is_global,
+          :provided_value,
+          :allowed_values
+
+      def initialize(name, type, defaultValue, noEcho = false, isGlobal = false, allowed_values = nil)
         @no_echo = noEcho
         @name = name
         @type = type
         @default_value = defaultValue
+        @is_global = isGlobal
+        @allowed_values = allowed_values
+        @provided_value = nil
       end
-    end
-
-    class StackParam < Parameter
-      attr_accessor :is_global
-    end
 
-    class ComponentParam < Parameter
-
-    end
-
-    class OutputParam < Parameter
-      attr_accessor :component
-
-      def initialize(component, name, default)
-        @component = component
-        @name = name
-        @default_value = default
-        @type = 'String'
-      end
     end
 
     class MappingParam < Parameter

data/lib/{cfhighlander.dsl.component.rb → cfhighlander.dsl.subcomponent.rb}

@@ -1,6 +1,7 @@
 require_relative './cfhighlander.helper'
 require_relative './cfhighlander.dsl.base'
 require_relative './cfhighlander.factory'
+require 'cfndsl'
 
 module Cfhighlander
 
@@ -15,7 +16,6 @@ module Cfhighlander
 
     end
 
-
     class Subcomponent < DslBase
 
       attr_accessor :name,
@@ -100,9 +100,6 @@ module Cfhighlander
       end
 
       def load(component_config_override = {})
-        # check for component config on parent
-        parent = @parent
-
         # Highest priority is DSL defined configuration
         component_config_override.extend @config
 
@@ -111,9 +108,13 @@ module Cfhighlander
         @component_loaded.load @component_config_override
       end
 
+      def parameter(name:, value:)
+        @param_values[name] = value
+      end
+
       # Parameters should be lazy loaded, that is late-binding should happen once
       # all parameters and mappings are known
-      def load_parameters
+      def resolve_parameter_values(available_outputs)
         component_dsl = @component_loaded.highlander_dsl
         component_dsl.parameters.param_list.each do |component_param|
           param = Cfhighlander::Dsl::SubcomponentParameter.new
@@ -121,7 +122,8 @@ module Cfhighlander
           param.cfndsl_value = SubcomponentParamValueResolver.resolveValue(
               @parent,
               self,
-              component_param)
+              component_param,
+              available_outputs)
           @parameters << param
         end
       end
@@ -129,40 +131,77 @@ module Cfhighlander
     end
 
     class SubcomponentParamValueResolver
-      def self.resolveValue(component, sub_component, param)
-
-        puts("Resolving parameter #{component.name} -> #{sub_component.name}.#{param.name}")
+      def self.resolveValue(component, sub_component, param, available_outputs)
+
+        print("INFO Resolving parameter #{component.name} -> #{sub_component.name}.#{param.name}: ")
+
+        # rule 0: this rule is here for legacy reasons and OutputParam. It should be deprecated
+        # once all hl-components- repos remove any references to OutputParam
+        if not param.provided_value.nil?
+          component_name = param.provided_value.split('.')[0]
+          output_name = param.provided_value.split('.')[1]
+          source_component = component.subcomponents.find {|c| c.name == component_name}
+          if source_component.nil?
+            source_component = component.subcomponents.find {|c| c.component_loaded.template.template_name == component_name}
+          end
+          return CfnDsl::Fn.new('GetAtt', [
+              source_component.name,
+              "Outputs.#{output_name}"
+          ]).to_json
+        end
 
-        # check if there are values defined on component itself
+        # rule 1: check if there are values defined on component itself
         if sub_component.param_values.key?(param.name)
-          return Cfhighlander::Helper.parameter_cfndsl_value(sub_component.param_values[param.name])
+          puts " parameter value provided "
+
+          param_value = sub_component.param_values[param.name]
+          if param_value.is_a? String and param_value.include? '.'
+            source_component_name = param_value.split('.')[0]
+            source_output = param_value.split('.')[1]
+            source_component = component.subcomponents.find {|sc| sc.name == source_component_name}
+            # if source component exists
+            if not source_component.nil?
+              if source_component_name == sub_component.name
+                STDERR.puts "WARNING: Parameter value on component #{source_component_name} references component itself: #{param_value}"
+              else
+                return CfnDsl::Fn.new('GetAtt', [
+                    source_component_name,
+                    "Outputs.#{source_output}"
+                ]).to_json
+              end
+            else
+              return Cfhighlander::Helper.parameter_cfndsl_value(param_value)
+            end
+          else
+            return Cfhighlander::Helper.parameter_cfndsl_value(sub_component.param_values[param.name])
+          end
         end
 
-        if param.class == Cfhighlander::Dsl::StackParam
-          return self.resolveStackParamValue(component, sub_component, param)
-        elsif param.class == Cfhighlander::Dsl::ComponentParam
-          return self.resolveComponentParamValue(component, sub_component, param)
-        elsif param.class == Cfhighlander::Dsl::MappingParam
+        # rule 1.1 mapping parameters are handled differently.
+        # TODO wire mapping parameters outside of component
+        if param.class == Cfhighlander::Dsl::MappingParam
+          puts " mapping parameter"
           return self.resolveMappingParamValue(component, sub_component, param)
-        elsif param.class == Cfhighlander::Dsl::OutputParam
-          return self.resolveOutputParamValue(component, sub_component, param)
-        else
-          raise "#{param.class} not resolvable to parameter value"
         end
-      end
 
-      def self.resolveStackParamValue(component, sub_component, param)
-        param_name = param.is_global ? param.name : "#{sub_component.name}#{param.name}"
-        return "Ref('#{param_name}')"
-      end
+        # rule #2: match output values from other components
+        #          by parameter name
+        if available_outputs.key? param.name
+          component_name = available_outputs[param.name].component.name
+          puts " resolved as output of #{component_name}"
+          return CfnDsl::Fn.new('GetAtt', [
+              component_name,
+              "Outputs.#{param.name}"
+          ]).to_json
+        end
+
+        # by default bubble parameter and resolve as reference on upper level
+        propagated_param = param.clone
+        propagated_param.name = "#{sub_component.name}#{param.name}" unless param.is_global
+        component.parameters.addParam propagated_param
+        puts " no autowiring candidates, propagate parameter to parent"
+        return CfnDsl::RefDefinition.new(propagated_param.name).to_json
 
-      def self.resolveComponentParamValue(component, sub_component, param)
-        # check component config for param value
-        # TODO
-        # check stack config for param value
-        # TODO
-        # return default value
-        return "'#{param.default_value}'"
       end
 
       def self.resolveMappingParamValue(component, sub_component, param)
@@ -207,37 +246,9 @@ module Cfhighlander
           return "''"
         end
 
-        return value
-
-
         return value
       end
 
-      def self.resolveOutputParamValue(component, sub_component, param)
-        component_name = param.component
-        resource_name = nil
-        if not sub_component.export_config.nil?
-          if sub_component.export_config.key? component_name
-            resource_name = sub_component.export_config[component_name]
-          end
-        end
-
-        if resource_name.nil?
-          # find by component
-          resource = component.components.find {|c| c.name == component_name}
-          resource_name = resource.name unless resource.nil?
-          if resource_name.nil?
-            resource = component.components.find {|c| c.template == component_name}
-            resource_name = resource.name unless resource.nil?
-          end
-        end
-
-        if resource_name.nil?
-          raise "#{sub_component.name}.Params.#{param.name}: Failed to resolve OutputParam '#{param.name}' with source '#{component_name}'. Component not found!"
-        end
-
-        return "FnGetAtt('#{resource_name}','Outputs.#{param.name}')"
-      end
     end
 
   end

data/lib/{cfhighlander.dsl.rb → cfhighlander.dsl.template.rb}

@@ -2,7 +2,7 @@
 
 extensions_folder = "#{File.dirname(__FILE__)}/../hl_ext"
 
-Dir["#{extensions_folder}/*.rb"].each { |f|
+Dir["#{extensions_folder}/*.rb"].each {|f|
   require f
 }
 
@@ -10,7 +10,7 @@ Dir["#{extensions_folder}/*.rb"].each { |f|
 
 require_relative './cfhighlander.dsl.base'
 require_relative './cfhighlander.dsl.params'
-require_relative './cfhighlander.dsl.component'
+require_relative './cfhighlander.dsl.subcomponent'
 
 module Cfhighlander
 
@@ -21,7 +21,7 @@ module Cfhighlander
       attr_accessor :mappings,
           :parameters,
           :name,
-          :components,
+          :subcomponents,
           :version,
           :distribute_url,
           :distribution_bucket,
@@ -32,7 +32,7 @@ module Cfhighlander
 
       def initialize
         @mappings = []
-        @components = []
+        @subcomponents = []
         @config = { 'mappings' => {}, 'component_version' => 'latest' }
         @component_configs = {}
         @version = 'latest'
@@ -74,7 +74,7 @@ module Cfhighlander
 
       def DynamicMappings(providerName)
         maps = mappings_provider_maps(providerName, self.config)
-        maps.each { |name, map| addMapping(name, map) } unless maps.nil?
+        maps.each {|name, map| addMapping(name, map)} unless maps.nil?
       end
 
       def DependsOn(template)
@@ -82,8 +82,20 @@ module Cfhighlander
       end
 
 
-      def Component(template:, name: template, param_values: {}, config: {}, export_config: {}, &block)
+      def Component(template_arg = nil, template: nil,
+          name: template,
+          param_values: {},
+          config: {},
+          export_config: {}, &block)
         puts "INFO: Requested subcomponent #{name} with template #{template}"
+        if ((not template_arg.nil?) and template.nil?)
+          template = template_arg
+        elsif (template_arg.nil? and template.nil?)
+          raise 'Component must be defined with template name at minimum,' +
+              ' passed as first argument, or template: named arguent'
+        end
+
+        name = template if name.nil?
 
         # load component
         component = Cfhighlander::Dsl::Subcomponent.new(self,
@@ -94,11 +106,12 @@ module Cfhighlander
             config,
             export_config
         )
+        component.instance_eval(&block) unless block.nil?
         component.distribute_bucket = @distribution_bucket unless @distribution_bucket.nil?
         component.distribute_prefix = @distribution_prefix unless @distribution_prefix.nil?
         component.version = @version unless @version.nil?
         @component_configs[name] = config
-        @components << component
+        @subcomponents << component
       end
 
       def ComponentVersion(version)
@@ -151,8 +164,8 @@ module Cfhighlander
       def loadComponents()
 
         # empty config overrides to start with
-        @config_overrides = Hash[@components.collect { |c| [c.name, {'nested_component' => true}] }]
-        @named_components = Hash[@components.collect { |c| [c.name, c] }]
+        @config_overrides = Hash[@subcomponents.collect {|c| [c.name, { 'nested_component' => true }]}]
+        @named_components = Hash[@subcomponents.collect {|c| [c.name, c]}]
 
         # populate overrides with master config defined overrides
         load_configfile_component_config
@@ -174,7 +187,7 @@ module Cfhighlander
 
 
         # load components and extract parent stack parameters and mappings
-        @components.each { |component|
+        @subcomponents.each do |component|
 
           component.load @config_overrides[component.name]
           # add all of it's stack parameters unless same template has been already processed
@@ -184,19 +197,6 @@ module Cfhighlander
               .parameters
               .param_list.each do |param|
 
-            # add stack parameters
-            if param.class == Cfhighlander::Dsl::StackParam
-              # sub-component stack param becomes top-level component param
-              param_name = param.is_global ? param.name : "#{component.name}#{param.name}"
-              stack_param = Cfhighlander::Dsl::ComponentParam.new(
-                  param_name,
-                  param.type,
-                  param.default_value,
-                  param.no_echo
-              )
-              @parameters.addParam stack_param
-            end unless component.param_values.key? param.name
-
             # for map parameters add maps
             if param.class == Cfhighlander::Dsl::MappingParam
               if not param.mapProvider.nil?
@@ -215,9 +215,21 @@ module Cfhighlander
 
           end
 
-          # late bind parameter values, once mappings and top level params are extracted
-          component.load_parameters
-        }
+          component.component_loaded.eval_cfndsl()
+        end
+
+        # in 2nd pass, load parameters
+        # 2nd pass is required as all of cfndsl models need to be populated
+        available_outputs = {}
+        @subcomponents.each do |c|
+          c.component_loaded.outputs.each do |out|
+            available_outputs[out.name] = out
+          end
+        end
+
+        @subcomponents.each do |component|
+          component.resolve_parameter_values available_outputs
+        end
 
         @dependson_components_templates.each do |template|
           component = Cfhighlander::Dsl::Subcomponent.new(self,
@@ -232,7 +244,7 @@ module Cfhighlander
       end
 
       def load_extension_exports
-        @components.each do |c|
+        @subcomponents.each do |c|
           component = c.component_loaded
           config = component.config
           if ((config.key? 'lib_export') and (config['lib_export'].key? 'global'))
@@ -241,7 +253,7 @@ module Cfhighlander
             if global_export_config.key? 'cfndsl'
               global_export_config['cfndsl'].each do |exported_extension|
                 extension_file_path = "#{component.component_dir}/ext/cfndsl/#{exported_extension}.rb"
-                @components.each do |cr|
+                @subcomponents.each do |cr|
                   cr.component_loaded.cfndsl_ext_files << extension_file_path unless cr == c
                 end
               end
@@ -252,14 +264,14 @@ module Cfhighlander
       end
 
       def apply_config_overrides
-        @config_overrides.each { |component_name, component_override|
+        @config_overrides.each {|component_name, component_override|
           @named_components[component_name].component_loaded.config.extend(component_override)
         }
       end
 
       def load_configfile_component_config
         if (@config.key? 'components')
-          @config['components'].each { |component_name, component_config|
+          @config['components'].each {|component_name, component_config|
             if component_config.key?('config')
               if @config_overrides.key? component_name
                 @config_overrides[component_name].extend(component_config['config'])
@@ -274,28 +286,28 @@ module Cfhighlander
       def apply_config_exports
         # first export from master to all children
         if ((@config.key? 'config_export') and (@config['config_export']['global']))
-          @config['config_export']['global'].each { |global_export_key|
+          @config['config_export']['global'].each {|global_export_key|
             if @config.key? global_export_key
-              @config_overrides.each { |cname, co|
+              @config_overrides.each {|cname, co|
                 co[global_export_key] = @config[global_export_key]
               }
             end
           }
         end
 
-        @components.each { |component|
+        @subcomponents.each {|component|
           cl = component.component_loaded
           if ((not cl.config.nil?) and (cl.config.key? 'config_export'))
 
             # global config
             if cl.config['config_export'].key? 'global'
-              cl.config['config_export']['global'].each { |global_export_key|
+              cl.config['config_export']['global'].each {|global_export_key|
 
                 # global config is exported to parent and every component
                 if cl.config.key? global_export_key
 
                   # cname is for component name, co for component override
-                  @config_overrides.each { |cname, co|
+                  @config_overrides.each {|cname, co|
 
                     # if templates are different e.g don't export from vpc to vpc
                     config_receiver_component = @named_components[cname]
@@ -321,7 +333,7 @@ module Cfhighlander
             end
 
             if cl.config['config_export'].key? 'component'
-              cl.config['config_export']['component'].each { |component_name, export_keys|
+              cl.config['config_export']['component'].each {|component_name, export_keys|
                 # check if there is configuration of export from this component
                 # and if there is export configuration for given component name
 
@@ -330,7 +342,7 @@ module Cfhighlander
                   if @config_overrides.key? component.export_config[component_name]
                     # override the config
                     real_component_name = component.export_config[component_name]
-                    export_keys.each { |export_component_key|
+                    export_keys.each {|export_component_key|
                       puts("Exporting config for key=#{export_component_key} from #{component.name} to #{real_component_name}")
                       if not @config_overrides[real_component_name].key? export_component_key
                         @config_overrides[real_component_name][export_component_key] = {}
@@ -341,7 +353,7 @@ module Cfhighlander
                     STDERR.puts("Trying to export configuration for non-existant component #{component.export_config[component_name]}")
                   end
                 elsif @config_overrides.key? component_name
-                  export_keys.each { |export_component_key|
+                  export_keys.each {|export_component_key|
                     puts("Exporting config for key=#{export_component_key} from #{component.name} to #{component_name}")
                     if not @config_overrides[component_name].key? export_component_key
                       @config_overrides[component_name][export_component_key] = {}
@@ -361,7 +373,7 @@ module Cfhighlander
       end
 
       def load_explicit_component_config
-        @component_configs.each { |component_name, component_config|
+        @component_configs.each {|component_name, component_config|
           @config_overrides[component_name].extend(component_config)
         }
       end
@@ -384,7 +396,7 @@ module Cfhighlander
         if not (@distribution_bucket.nil? or @distribution_prefix.nil?)
           @distribute_url = "https://#{@distribution_bucket}.s3.amazonaws.com/#{@distribution_prefix}"
           @distribute_url = "#{@distribute_url}/#{@version}" unless @version.nil?
-          @components.each { |component|
+          @subcomponents.each {|component|
             component.distribute_bucket = @distribution_bucket unless @distribution_bucket.nil?
             component.distribute_prefix = @distribution_prefix unless @distribution_prefix.nil?
             component.version = @version unless @version.nil?
@@ -399,7 +411,7 @@ module Cfhighlander
 
 end
 
-def HighlanderComponent(&block)
+def CfhighlanderTemplate(&block)
   instance = Cfhighlander::Dsl::HighlanderTemplate.new
 
   puts "Processing higlander component #{@name}\n\tLocation:#{@highlander_dsl_path}" +
@@ -435,5 +447,11 @@ def HighlanderComponent(&block)
 end
 
 def CfhighlanderComponent(&block)
-  HighlanderComponent(&block)
+  STDERR.puts("DEPRECATED: #{@template.template_name}: use CfhighlanderTemplate instead of CfhighlanderComponent")
+  CfhighlanderTemplate(&block)
+end
+
+def HighlanderComponent(&block)
+  STDERR.puts("DEPRECATED: #{@template.template_name}: use CfhighlanderTemplate instead of HighlanderComponent")
+  CfhighlanderTemplate(&block)
 end

data/lib/cfhighlander.factory.rb

@@ -1,4 +1,4 @@
-require_relative './cfhighlander.dsl'
+require_relative './cfhighlander.dsl.template'
 require_relative './cfhighlander.factory.templatefinder'
 require_relative './cfhighlander.model.component'
 require 'fileutils'

data/lib/cfhighlander.helper.rb

@@ -11,7 +11,7 @@ module Cfhighlander
       end
 
       if value.class == Hash
-        return value.to_s
+        return value.to_json
       end
 
       return "'#{value}'"

data/lib/cfhighlander.model.component.rb

@@ -22,6 +22,8 @@ module Cfhighlander
           :cfndsl_ext_files,
           :lambda_src_files
 
+      attr_reader :cfn_model, :outputs
+
       def initialize(template_meta, component_name)
         @template = template_meta
         @name = component_name
@@ -69,7 +71,7 @@ module Cfhighlander
           STDERR.puts "DEPRECATED: #{legacy_cfhighlander_path} - Use *.cfhiglander.rb"
           @highlander_dsl_path = legacy_cfhighlander_path
         else
-          @highlander_dsl_path =  "#{@component_dir}/#{@template.template_name}.cfhighlander.rb"
+          @highlander_dsl_path = "#{@component_dir}/#{@template.template_name}.cfhighlander.rb"
         end
 
         @cfndsl_path = "#{@component_dir}/#{@template.template_name}.cfndsl.rb"
@@ -88,10 +90,7 @@ module Cfhighlander
         @config['component_name'] = @name
         @config['template_name'] = @template.template_name
         @config['template_version'] = @template.template_version
-        # allow override of components
-        # config_override.each do |key, value|
-        #   @config[key] = value
-        # end unless config_override.nil?
+
 
         Dir[candidate_mappings_path].each do |mapping_file|
           mappings = YAML.load(File.read(mapping_file))
@@ -145,6 +144,31 @@ module Cfhighlander
 
         loadDepandantExt()
       end
+
+      # evaluates cfndsl with current config
+      def eval_cfndsl
+        compiler = Cfhighlander::Compiler::ComponentCompiler.new self
+        @cfn_model = compiler.evaluateCloudFormation().as_json
+        @outputs = (
+        if @cfn_model.key? 'Outputs'
+        then
+          @cfn_model['Outputs'].map {|k, v| ComponentOutput.new self, k, v}
+        else
+          []
+        end
+        )
+      end
+    end
+
+    class ComponentOutput
+
+      attr_reader :component, :name, :value
+
+      def initialize(component, name, value)
+        @component = component
+        @name = name
+        @value = value
+      end
     end
 
   end

data/templates/cfndsl.component.template.erb

@@ -8,7 +8,7 @@ CloudFormation do
 <% end %>
 
 # render subcomponents
-<% for @component in dsl.components %>
+<% for @component in dsl.subcomponents %>
     CloudFormation_Stack('<%= @component.name.gsub('-','').gsub('_','') %>') do
     TemplateURL '<%= @component.distribution_url %>'
     Parameters ({
@@ -38,6 +38,9 @@ CloudFormation do
       <% unless @param.no_echo.nil? %>
       NoEcho <%= @param.no_echo.to_s %>
       <% end %>
+      <% unless @param.allowed_values.nil? %>
+        AllowedValues <%= @param.allowed_values.to_s %>
+      <% end %>
     end
 <% end %>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cfhighlander
 version: !ruby/object:Gem::Version
-  version: 0.2.1.alpha.34
+  version: 0.2.1.alpha.43
 platform: ruby
 authors:
 - Nikola Tosic
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-05 00:00:00.000000000 Z
+date: 2018-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -245,9 +245,9 @@ files:
 - hl_ext/vpc.rb
 - lib/cfhighlander.compiler.rb
 - lib/cfhighlander.dsl.base.rb
-- lib/cfhighlander.dsl.component.rb
 - lib/cfhighlander.dsl.params.rb
-- lib/cfhighlander.dsl.rb
+- lib/cfhighlander.dsl.subcomponent.rb
+- lib/cfhighlander.dsl.template.rb
 - lib/cfhighlander.factory.rb
 - lib/cfhighlander.factory.templatefinder.rb
 - lib/cfhighlander.helper.rb