cfhighlander 0.2.1 → 0.3.0.alpha.1528936037

data/lib/{highlander.compiler.rb → cfhighlander.compiler.rb}

@@ -12,7 +12,7 @@ require 'highline/import'
 require 'zip'
 require_relative './util/zip.util'
 
-module Highlander
+module Cfhighlander
 
   module Compiler
 
@@ -33,7 +33,7 @@ module Highlander
 
       def initialize(component)
 
-        @workdir = ENV['HIGHLANDER_WORKDIR']
+        @workdir = ENV['CFHIGHLANDER_WORKDIR']
         @component = component
         @sub_components = []
         @component_name = component.highlander_dsl.name.downcase
@@ -43,14 +43,16 @@ module Highlander
         @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|
-          sub_component_compiler = Highlander::Compiler::ComponentCompiler.new(sub_component.component_loaded)
+        @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
         end
@@ -67,7 +69,7 @@ module Highlander
         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 Highlander
 
       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 Highlander
           end
         end
         @config_written = true
-        config_yaml_path
+        @config_yaml_path = config_yaml_path
+        return @config_yaml_path
       end
 
       def processLambdas()
@@ -281,7 +289,7 @@ module Highlander
               end
             end
             File.delete full_destination_path if File.exist? full_destination_path
-            zip_generator = Highlander::Util::ZipFileGenerator.new(lambda_source_dir, full_destination_path)
+            zip_generator = Cfhighlander::Util::ZipFileGenerator.new(lambda_source_dir, full_destination_path)
             zip_generator.write
 
           end

data/lib/{highlander.dsl.base.rb → cfhighlander.dsl.base.rb}

@@ -1,5 +1,5 @@
 
-module Highlander
+module Cfhighlander
 
   module Dsl
     class DslBase
@@ -15,10 +15,11 @@ module Highlander
           raise StandardError, "#{self} no config!"
         end
         return @config["#{method}"] unless @config["#{method}"].nil?
-        raise StandardError, "#{self}Unknown method or variable #{method} in Highlander template"
+        raise StandardError, "#{self} Unknown method or variable #{method} in Cfhighlander template"
       end
 
     end
+
   end
 
 end

data/lib/cfhighlander.dsl.params.rb

@@ -0,0 +1,108 @@
+require_relative './cfhighlander.dsl.base'
+
+module Cfhighlander
+
+  module Dsl
+
+    # dsl statements
+    class Parameters < DslBase
+
+      attr_accessor :param_list
+
+      def initialize()
+        @param_list = []
+      end
+
+      def addParam(param)
+        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
+        else
+          @param_list << param
+        end
+      end
+
+      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 = '', 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)
+        param = MappingParam.new(name, 'String', defaultValue)
+        param.config = @config
+        param.instance_eval(&block)
+        addParam param
+      end
+
+
+    end
+
+    # model classes
+    class Parameter < DslBase
+      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 MappingParam < Parameter
+
+      attr_accessor :mapName, :mapKey, :mapAttribute
+
+      def method_missing(method, *args)
+        smethod = "#{method}"
+        if smethod.start_with?('Map')
+          puts smethod
+        end
+
+        super.method_missing(method)
+      end
+
+      def key(map_key)
+        @mapKey = map_key
+      end
+
+      def attribute(key)
+        @mapAttribute = key
+      end
+
+      def map(mapName)
+        @mapName = mapName
+      end
+
+      def mapProvider
+        mappings_provider(@mapName)
+      end
+
+    end
+  end
+end

data/lib/cfhighlander.dsl.subcomponent.rb

@@ -0,0 +1,274 @@
+require_relative './cfhighlander.helper'
+require_relative './cfhighlander.dsl.base'
+require_relative './cfhighlander.factory'
+require 'cfndsl'
+
+module Cfhighlander
+
+  module Dsl
+
+    class SubcomponentParameter
+      attr_accessor :name, :cfndsl_value
+
+      def initialize
+
+      end
+
+    end
+
+    class Subcomponent < DslBase
+
+      attr_accessor :distribution_format,
+          :distribution_location,
+          :distribution_url,
+          :distribution_format,
+          :component_loaded,
+          :parameters,
+          :param_values,
+          :component_config_override,
+          :export_config
+
+
+      attr_reader :cfn_name,
+          :conditional,
+          :parent,
+          :name,
+          :template,
+          :template_version
+
+      def initialize(parent,
+          name,
+          template,
+          param_values,
+          component_sources = [],
+          config = {},
+          export_config = {},
+          conditional = false,
+          enabled = true,
+          distribution_format = 'yaml')
+
+        @parent = parent
+        @config = config
+        @export_config = export_config
+        @component_sources = component_sources
+        @conditional = conditional
+
+        template_name = template
+        template_version = 'latest'
+        if template.include?('@') and not (template.start_with? 'git')
+          template_name = template.split('@')[0]
+          template_version = template.split('@')[1]
+        end
+
+        @template = template_name
+        @template_version = template_version
+        @name = name
+        @cfn_name = @name.gsub('-','').gsub('_','').gsub(' ','')
+        @param_values = param_values
+
+        # distribution settings
+        @distribution_format = distribution_format
+        # by default components located at same location as master stack
+        @distribution_location = '.'
+        build_distribution_url
+
+        # load component
+        factory = Cfhighlander::Factory::ComponentFactory.new(@component_sources)
+        @component_loaded = factory.loadComponentFromTemplate(
+            @template,
+            @template_version,
+            @name
+        )
+        @component_loaded.config.extend @config
+
+        @parameters = []
+
+        # add condition to parent if conditonal component
+        if @conditional
+          condition_param_name = "Enable#{@cfn_name}"
+          @parent.Condition(condition_param_name, CfnDsl::Fn.new('Equals', [
+              CfnDsl::RefDefinition.new(condition_param_name),
+              'true'
+          ]).to_json)
+          @parent.Parameters do
+            ComponentParam condition_param_name, enabled.to_s, allowedValues: %w(true false)
+          end
+        end
+      end
+
+      def version=(value)
+        @component_loaded.version = value
+      end
+
+      def distribute_bucket=(value)
+        @component_loaded.distribution_bucket = value
+      end
+
+      def distribute_prefix=(value)
+        @component_loaded.distribution_prefix = value
+      end
+
+      def distribution_format=(value)
+        @distribution_format = value
+        build_distribution_url
+      end
+
+      def build_distribution_url
+        @distribution_location = @parent.distribute_url unless @parent.distribute_url.nil?
+        @distribution_url = "#{@distribution_location}/#{@name}.compiled.#{@distribution_format}"
+      end
+
+      def load(component_config_override = {})
+        # Highest priority is DSL defined configuration
+        component_config_override.extend @config
+
+        @component_config_override = component_config_override
+
+        @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 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
+          param.name = component_param.name
+          param.cfndsl_value = SubcomponentParamValueResolver.resolveValue(
+              @parent,
+              self,
+              component_param,
+              available_outputs)
+          @parameters << param
+        end
+      end
+
+    end
+
+    class SubcomponentParamValueResolver
+      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
+
+        # rule 1: check if there are values defined on component itself
+        if sub_component.param_values.key?(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
+
+        # 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)
+        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.cfn_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
+
+      end
+
+      def self.resolveMappingParamValue(component, sub_component, param)
+
+        # determine map name
+
+        provider = nil
+
+        mappings_name = param.mapName
+        actual_map_name = mappings_name
+
+        key_name = nil
+
+        # priority 0: stack-level parameter of map name
+        stack_param_mapname = component.parameters.param_list.find {|p| p.name == mappings_name}
+        unless stack_param_mapname.nil?
+          key_name = "Ref('#{mappings_name}')"
+        end
+
+        # priority 1 mapping provider keyName - used as lowest priority
+        if key_name.nil?
+          provider = mappings_provider(mappings_name)
+          if ((not provider.nil?) and (provider.respond_to?('getDefaultKey')))
+            key_name = provider.getDefaultKey
+          end
+        end
+
+        # priority 2: dsl defined key name
+        if key_name.nil?
+          key_name = param.mapKey
+          # could still be nil after this line
+        end
+
+        value = mapping_value(component: component,
+            provider_name: mappings_name,
+            value_name: param.mapAttribute,
+            key_name: key_name
+        )
+
+        if value.nil?
+          return "'#{param.default_value}'" unless param.default_value.empty?
+          return "''"
+        end
+
+        return value
+      end
+
+    end
+
+  end
+end