cfhighlander 0.2.1.alpha.43 → 0.2.1

data/cfndsl_ext/sg.rb

@@ -1,4 +1,3 @@
-require 'netaddr'
 
 def sg_create_rules (x, ip_blocks={})
   rules = []
@@ -16,38 +15,12 @@ end
 
 
 def lookup_ips_for_sg (ips, ip_block_name={})
-  cidr = []
   if ip_block_name == 'stack'
     cidr = [FnJoin( "", [ "10.", Ref('StackOctet'), ".", "0.0/16" ] )]
   elsif ips.has_key? ip_block_name
-    ips[ip_block_name].each do |ip|
-      if (ips.include?(ip) || ip_block_name == 'stack')
-        cidr += lookup_ips_for_sg(ips, ip) unless ip == ip_block_name
-      else
-        if ip == 'stack'
-          cidr << [FnJoin( "", [ "10.", Ref('StackOctet'), ".", "0.0/16" ] )]
-        elsif(isCidr(ip))
-          cidr << ip
-        else
-          STDERR.puts("WARN: ip #{ip} is not a valid CIDR. Ignoring IP")
-        end
-      end
-    end
+    cidr = ips[ip_block_name]
   else
-    if isCidr(ip_block_name)
-      cidr = [ip_block_name]
-    else
-      STDERR.puts("WARN: ip #{ip_block_name} is not a valid CIDR. Ignoring IP")
-    end
+    cidr = [ip_block_name]
   end
   cidr
 end
-
-def isCidr(block)
-  begin
-    NetAddr::CIDR.create(block)
-    return block.include?('/')
-  rescue NetAddr::ValidationError
-    return false
-  end
-end

data/hl_ext/mapping_helper.rb

@@ -1,16 +1,14 @@
-require_relative '../lib/cfhighlander.mapproviders'
+require_relative '../lib/highlander.mapproviders'
 
 # Return mapping provider as class
-def mappings_provider(provider_name, is_legacy = false)
+def mappings_provider(provider_name)
   return nil if provider_name.nil?
   provider = nil
-  module_name = is_legacy ? 'Highlander': 'Cfhighlander'
-  providers = Object.const_get(module_name).const_get('MapProviders')
+  providers = Object.const_get('Highlander').const_get('MapProviders')
   begin
     providers.const_get(provider_name)
   rescue NameError => e
-    if e.to_s.include? "uninitialized constant #{module_name}::MapProviders::"
-      return mappings_provider(provider_name, true) unless is_legacy
+    if e.to_s.include? 'uninitialized constant Highlander::MapProviders::'
       return nil
     end
     STDERR.puts(e.to_s)

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

@@ -12,7 +12,7 @@ require 'highline/import'
 require 'zip'
 require_relative './util/zip.util'
 
-module Cfhighlander
+module Highlander
 
   module Compiler
 
@@ -33,7 +33,7 @@ module Cfhighlander
 
       def initialize(component)
 
-        @workdir = ENV['CFHIGHLANDER_WORKDIR']
+        @workdir = ENV['HIGHLANDER_WORKDIR']
         @component = component
         @sub_components = []
         @component_name = component.highlander_dsl.name.downcase
@@ -43,16 +43,14 @@ 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.subcomponents.each do |sub_component|
-          sub_component_compiler = Cfhighlander::Compiler::ComponentCompiler.new(sub_component.component_loaded)
+        @component.highlander_dsl.components.each do |sub_component|
+          sub_component_compiler = Highlander::Compiler::ComponentCompiler.new(sub_component.component_loaded)
           sub_component_compiler.component_name = sub_component.name
           @sub_components << sub_component_compiler
         end
@@ -69,7 +67,7 @@ module Cfhighlander
         dsl = @component.highlander_dsl
         component_cfndsl = @component.cfndsl_content
 
-        @component.highlander_dsl.subcomponents.each { |sc|
+        @component.highlander_dsl.components.each { |sc|
           sc.distribution_format = out_format
         }
 
@@ -102,38 +100,33 @@ module Cfhighlander
 
       end
 
-      def evaluateCloudFormation(format = 'yaml')
-        #compile cfndsl templates first
-        compileCfnDsl format unless @cfndsl_compiled
-
-        # write config
-        cfndsl_opts = []
-        cfndsl_opts.push([:yaml, @config_yaml_path])
+      def compileCloudFormation(format = 'yaml')
 
-        # 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')
+        #compile cfndsl templates first
+        compileCfnDsl format unless @cfndsl_compiled
 
         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 = evaluateCloudFormation
+        model = CfnDsl.eval_file_with_extras(@cfndsl_compiled_path, cfndsl_opts, false)
 
         # write resulting cloud formation template
         if format == 'json'
@@ -172,8 +165,7 @@ module Cfhighlander
           end
         end
         @config_written = true
-        @config_yaml_path = config_yaml_path
-        return @config_yaml_path
+        config_yaml_path
       end
 
       def processLambdas()
@@ -289,7 +281,7 @@ module Cfhighlander
               end
             end
             File.delete full_destination_path if File.exist? full_destination_path
-            zip_generator = Cfhighlander::Util::ZipFileGenerator.new(lambda_source_dir, full_destination_path)
+            zip_generator = Highlander::Util::ZipFileGenerator.new(lambda_source_dir, full_destination_path)
             zip_generator.write
 
           end

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

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

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

@@ -1,9 +1,8 @@
-require_relative './cfhighlander.helper'
-require_relative './cfhighlander.dsl.base'
-require_relative './cfhighlander.factory'
-require 'cfndsl'
+require_relative './highlander.helper'
+require_relative './highlander.dsl.base'
+require_relative './highlander.factory'
 
-module Cfhighlander
+module Highlander
 
   module Dsl
 
@@ -16,7 +15,8 @@ module Cfhighlander
 
     end
 
-    class Subcomponent < DslBase
+
+    class Component < DslBase
 
       attr_accessor :name,
           :template,
@@ -65,11 +65,10 @@ module Cfhighlander
         build_distribution_url
 
         # load component
-        factory = Cfhighlander::Factory::ComponentFactory.new(@component_sources)
-        @component_loaded = factory.loadComponentFromTemplate(
+        factory = Highlander::Factory::ComponentFactory.new(@component_sources)
+        @component_loaded = factory.findComponent(
             @template,
-            @template_version,
-            @name
+            @template_version
         )
         @component_loaded.config.extend @config
 
@@ -100,6 +99,9 @@ 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
 
@@ -108,22 +110,17 @@ 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 resolve_parameter_values(available_outputs)
+      def load_parameters
         component_dsl = @component_loaded.highlander_dsl
         component_dsl.parameters.param_list.each do |component_param|
-          param = Cfhighlander::Dsl::SubcomponentParameter.new
+          param = Highlander::Dsl::SubcomponentParameter.new
           param.name = component_param.name
           param.cfndsl_value = SubcomponentParamValueResolver.resolveValue(
               @parent,
               self,
-              component_param,
-              available_outputs)
+              component_param)
           @parameters << param
         end
       end
@@ -131,77 +128,40 @@ module Cfhighlander
     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
+      def self.resolveValue(component, sub_component, param)
 
-        # rule 1: check if there are values defined on component itself
+        puts("Resolving parameter #{component.name} -> #{sub_component.name}.#{param.name}")
+
+        # 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
+          return Highlander::Helper.parameter_cfndsl_value(sub_component.param_values[param.name])
         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"
+        if param.class == Highlander::Dsl::StackParam
+          return self.resolveStackParamValue(component, sub_component, param)
+        elsif param.class == Highlander::Dsl::ComponentParam
+          return self.resolveComponentParamValue(component, sub_component, param)
+        elsif param.class == Highlander::Dsl::MappingParam
           return self.resolveMappingParamValue(component, sub_component, param)
+        elsif param.class == Highlander::Dsl::OutputParam
+          return self.resolveOutputParamValue(component, sub_component, param)
+        else
+          raise "#{param.class} not resolvable to parameter value"
         end
+      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.resolveStackParamValue(component, sub_component, param)
+        param_name = param.is_global ? param.name : "#{sub_component.name}#{param.name}"
+        return "Ref('#{param_name}')"
+      end
 
+      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)
@@ -216,7 +176,7 @@ module Cfhighlander
         key_name = nil
 
         # priority 0: stack-level parameter of map name
-        stack_param_mapname = component.parameters.param_list.find {|p| p.name == mappings_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
@@ -235,7 +195,7 @@ module Cfhighlander
           # could still be nil after this line
         end
 
-        value = mapping_value(component: component,
+        value =  mapping_value(component: component,
             provider_name: mappings_name,
             value_name: param.mapAttribute,
             key_name: key_name
@@ -246,9 +206,37 @@ 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/highlander.dsl.params.rb

@@ -0,0 +1,113 @@
+require_relative './highlander.dsl.base'
+
+module Highlander
+
+  module Dsl
+    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)
+        param = StackParam.new(name, 'String', defaultValue)
+        param.is_global = isGlobal
+        param.config = @config
+        param.no_echo = noEcho
+        addParam param
+      end
+
+      def ComponentParam(name, defaultValue='')
+        param = ComponentParam.new(name, 'String', defaultValue)
+        param.config = @config
+        addParam param
+      end
+
+      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
+
+    class Parameter < DslBase
+      attr_accessor :name, :type, :default_value, :no_echo
+
+      def initialize(name, type, defaultValue, noEcho = false)
+        @no_echo = noEcho
+        @name = name
+        @type = type
+        @default_value = defaultValue
+      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
+
+      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