convection 0.0.1 → 0.2.1

data/lib/convection/model/mixin/protocol.rb

@@ -0,0 +1,29 @@
+require 'netaddr'
+
+module Convection
+  module Model
+    module Mixin
+      ##
+      # Map IP protocol names to numbers
+      ##
+      module Protocol
+        class << self
+          def lookup(value)
+            case value
+            when :any then -1
+            when :icmp then 1
+            when :tcp then 6
+            when :udp then 17
+            else value
+            end
+          end
+        end
+
+        def protocol_property(name = :protocol, property_name = 'IpProtocol')
+          property(name, property_name,
+                   :transform => Mixin::Protocol.method(:lookup))
+        end
+      end
+    end
+  end
+end

data/lib/convection/model/mixin/taggable.rb

@@ -9,8 +9,8 @@ module Convection
       def render
         map do |t|
           {
-            :Key => t[0].to_s,
-            :Value => t[1]
+            'Key' => t[0].to_s,
+            'Value' => t[1]
           }
         end
       end

data/lib/convection/model/template.rb

@@ -1,5 +1,7 @@
 require_relative '../dsl/helpers'
 require_relative '../dsl/intrinsic_functions'
+require_relative './diff'
+require_relative './exceptions.rb'
 require 'json'
 
 module Convection
@@ -8,6 +10,44 @@ module Convection
     # Template DSL
     ##
     module Template
+      ##
+      # Container for DSL interfaces
+      ##
+      module Resource
+        class << self
+          ## Wrap private define_method
+          def attach_resource(name, klass)
+            define_method(name) do |rname, &block|
+              resource = klass.new(rname, self)
+              resource.instance_exec(&block) if block
+
+              resources[rname] = resource
+            end
+          end
+        end
+      end
+
+      include DSL::Helpers
+      include DSL::Template::Resource
+
+      CF_MAX_BYTESIZE = 51_200
+      CF_MAX_DESCRIPTION_BYTESIZE = 1_024
+      CF_MAX_MAPPING_ATTRIBUTE_NAME = 255
+      CF_MAX_MAPPING_ATTRIBUTES = 30
+      CF_MAX_MAPPING_NAME = 25
+      CF_MAX_MAPPINGS = 100
+      CF_MAX_OUTPUT_NAME_CHARACTERS = 255
+      CF_MAX_OUTPUTS = 60
+      CF_MAX_PARAMETER_NAME_CHARACTERS = 255
+      CF_MAX_PARAMETERS = 60
+      CF_MAX_PARAMETER_VALUE_BYTESIZE = 4_086
+      CF_MAX_RESOURCE_NAME = 255
+      CF_MAX_RESOURCES = 200
+
+      attribute :name
+      attribute :version
+      attribute :description
+
       def parameter(name, &block)
         pa = Model::Template::Parameter.new(name, self)
 
@@ -22,12 +62,12 @@ module Convection
         mappings[name] = m
       end
 
-      # def condition(name, &block)
-      #   c = Model::Template::Condition.new
-      #   c.instance_exec(&block) if block
-      #
-      #   conditions[name] = c
-      # end
+      def condition(name, &block)
+        c = Model::Template::Condition.new(name, self)
+
+        c.instance_exec(&block) if block
+        conditions[name] = c
+      end
 
       def resource(name, &block)
         r = Model::Template::Resource.new(name, self)
@@ -50,42 +90,106 @@ module Convection
     # Mapable hash
     ##
     class Collection < Hash
-      def map(&block)
+      def map(no_nil = false, &block)
         result = {}
 
         each do |key, value|
-          result[key] = block.call(value)
+          res = block.call(value)
+
+          next if no_nil && res.nil?
+          next if no_nil && res.is_a?(Array) && res.empty?
+          next if no_nil && res.is_a?(Hash) && res.empty?
+
+          result[key] = res
         end
 
         result
       end
     end
 
+    ##
+    # HACK: Add generic diff(other) and properties to Hash and Array
+    ##
+    class ::Array
+      ## Recursivly flatten an array into 1st order key/value pairs
+      def properties(memo = {}, path = '')
+        each_with_index do |elm, i|
+          if elm.is_a?(Hash) || elm.is_a?(Array)
+            elm.properties(memo, "#{path}.#{i}")
+          else
+            memo["#{path}.#{i}"] = elm
+          end
+        end
+
+        memo
+      end
+    end
+
+    ##
+    # HACK: Add generic diff(other) and properties to Hash and Array
+    ##
+    class ::Hash
+      ## Use flattened properties to calculate a diff
+      def diff(other = {})
+        our_properties = properties
+        their_properties = other.properties
+
+        (our_properties.keys + their_properties.keys).uniq.each_with_object({}) do |key, memo|
+          next if (our_properties[key] == their_properties[key] rescue false)
+
+          ## HACK: String/Number/Symbol comparison
+          if our_properties[key].is_a?(Numeric) ||
+             their_properties[key].is_a?(Numeric) ||
+             our_properties[key].is_a?(Symbol) ||
+             their_properties[key].is_a?(Symbol)
+            next if our_properties[key].to_s == their_properties[key].to_s
+          end
+
+          memo[key] = [our_properties[key], their_properties[key]]
+        end
+      end
+
+      ## Recursivly flatten a hash into 1st order key/value pairs
+      def properties(memo = {}, path = '')
+        keys.each do |key|
+          if self[key].is_a?(Hash) || self[key].is_a?(Array)
+            self[key].properties(memo, "#{path}.#{key}")
+          else
+            memo["#{path}.#{key}"] = self[key]
+          end
+        end
+
+        memo
+      end
+    end
+
     ##
     # Template container class
     ##
     class Template
-      extend DSL::Helpers
-
       include DSL::IntrinsicFunctions
       include DSL::Template
 
       DEFAULT_VERSION = '2010-09-09'
 
-      attribute :version
-      attribute :description
-      attribute :region
-
       attr_reader :stack
+      attr_reader :attribute_mappings
+
       attr_reader :parameters
       attr_reader :mappings
       attr_reader :conditions
       attr_reader :resources
       attr_reader :outputs
 
-      def initialize(stack = Control::Stack.new('default', self), &block)
+      def template
+        self
+      end
+
+      def initialize(stack = nil, &block)
         @definition = block
+
         @stack = stack
+        @attribute_mappings = {}
 
         @version = DEFAULT_VERSION
         @description = ''
@@ -97,11 +201,20 @@ module Convection
         @outputs = Collection.new
       end
 
-      def render(stack = nil)
-        ## Instantiate a new template with the definition block and an other stack
-        return Template.new(stack, &@definition).render unless stack.nil?
+      def clone(stack_)
+        Template.new(stack_, &@definition)
+      end
 
+      def execute
         instance_exec(&@definition)
+      end
+
+      def render(stack_ = nil)
+        ## Instantiate a new template with the definition block and an other stack
+        return clone(stack_).render unless stack_.nil?
+
+        execute ## Process the template document
+
         {
           'AWSTemplateFormatVersion' => version,
           'Description' => description,
@@ -113,8 +226,122 @@ module Convection
         }
       end
 
-      def to_json(stack = nil)
-        JSON.pretty_generate(render(stack))
+      def diff(other, stack_ = nil)
+        render(stack_).diff(other).map { |diff| Diff.new(diff[0], *diff[1]) }
+      end
+
+      def to_json(stack_ = nil, pretty = false)
+        rendered_stack = render(stack_)
+        validate(rendered_stack)
+        return JSON.generate(rendered_stack) unless pretty
+        JSON.pretty_generate(rendered_stack)
+      end
+
+      def validate(rendered_stack = nil)
+        %w(resources mappings parameters outputs description bytesize).map do |method|
+          send("validate_#{method}", rendered_stack)
+        end
+      end
+
+      def validate_compare(value, cf_max, error)
+        limit_exceeded_error(value, cf_max, error) if value > cf_max
+      end
+
+      def validate_resources(rendered_stack)
+        validate_compare(
+          rendered_stack['Resources'].count,
+          CF_MAX_RESOURCES,
+          ExcessiveResourcesError)
+
+        largest_resource_name = resources.keys.max || ''
+        validate_compare(
+          largest_resource_name.length,
+          CF_MAX_RESOURCE_NAME,
+          ExcessiveResourceNameError)
+      end
+
+      def validate_mappings(rendered_stack)
+        mappings = rendered_stack ['Mappings']
+        validate_compare(
+          mappings.count,
+          CF_MAX_MAPPINGS,
+          ExcessiveMappingsError)
+        mappings.each do |_, value|
+          validate_compare(
+            value.count,
+            CF_MAX_MAPPING_ATTRIBUTES,
+            ExcessiveMappingAttributesError)
+        end
+
+        mappings.keys.each do |key|
+          validate_compare(
+            key.length,
+            CF_MAX_MAPPING_NAME,
+            ExcessiveMappingNameError)
+        end
+
+        ## XXX What are we trying to do here @aburke
+        mapping_attributes = mappings.values.flat_map do |inner_hash|
+          inner_hash.keys.select do |key|
+            value = inner_hash[key]
+          end
+        end
+
+        mapping_attributes.each do |attribute|
+          validate_compare(
+            attribute.length,
+            CF_MAX_MAPPING_ATTRIBUTE_NAME,
+            ExcessiveMappingAttributeNameError)
+        end
+      end
+
+      def validate_parameters(rendered_stack)
+        parameters = rendered_stack['Parameters']
+        validate_compare(
+          parameters.count,
+          CF_MAX_PARAMETERS,
+          ExcessiveParametersError)
+        largest_parameter_name = parameters.keys.max
+        largest_parameter_name ||= ''
+        validate_compare(
+          largest_parameter_name.length,
+          CF_MAX_PARAMETER_NAME_CHARACTERS,
+          ExcessiveParameterNameError)
+        parameters.values.each do |value|
+          validate_compare(
+            JSON.generate(value).bytesize,
+            CF_MAX_PARAMETER_VALUE_BYTESIZE,
+            ExcessiveParameterBytesizeError)
+        end
+      end
+
+      def validate_outputs(rendered_stack)
+        outputs = rendered_stack['Outputs']
+        validate_compare(
+          outputs.count,
+          CF_MAX_OUTPUTS,
+          ExcessiveOutputsError)
+        largest_output_name = outputs.keys.max
+        largest_output_name ||= ''
+        validate_compare(
+          largest_output_name.length,
+          CF_MAX_OUTPUT_NAME_CHARACTERS,
+          ExcessiveOutputNameError)
+      end
+
+      def validate_description(rendered_stack)
+        validate_compare(
+          rendered_stack['Description'].bytesize,
+          CF_MAX_DESCRIPTION_BYTESIZE,
+          ExcessiveDescriptionError)
+      end
+
+      def validate_bytesize(rendered_stack)
+        json = JSON.generate(rendered_stack)
+        validate_compare(
+          json.bytesize,
+          CF_MAX_BYTESIZE,
+          ExcessiveTemplateSizeError)
       end
     end
   end
@@ -122,6 +349,6 @@ end
 
 require_relative 'template/parameter'
 require_relative 'template/mapping'
-# require_relative 'template/condition'
+require_relative 'template/condition'
 require_relative 'template/resource'
 require_relative 'template/output'

data/lib/convection/model/template/condition.rb

@@ -0,0 +1,56 @@
+require_relative '../../dsl/intrinsic_functions'
+
+module Convection
+  module Model
+    class Template
+      class Condition
+        include DSL::Helpers
+
+        CONDITIONAL_FUNCTION_SYNTAX_MAP =
+          { fn_and: 'Fn::And',
+            fn_equals: 'Fn::Equals',
+            fn_if: 'Fn::If',
+            fn_not: 'Fn::Not',
+            fn_or: 'Fn::Or' }
+
+        attr_reader :condition
+        attr_reader :template
+
+        CONDITIONAL_FUNCTION_SYNTAX_MAP.keys.each do |conditional_function|
+          define_method(conditional_function) do |*args|
+            @condition = ConditionalFunction.new conditional_function, args
+          end
+        end
+
+        def initialize(name, parent)
+          @name = name
+          @template = parent.template
+        end
+
+        def render
+          condition.render
+        end
+
+        class ConditionalFunction
+          def initialize(function_name, arg_array)
+            @function_name = function_name
+            @function_arguments = arg_array
+          end
+
+          def render
+            rendered_values = []
+            @function_arguments.each do |function_arg|
+              if function_arg.respond_to? :render # the argument is another conditional function
+                rendered_values << function_arg.render
+              else
+                rendered_values << function_arg
+              end
+            end
+
+            { CONDITIONAL_FUNCTION_SYNTAX_MAP[@function_name] => rendered_values }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convection/model/template/mapping.rb

@@ -18,13 +18,14 @@ module Convection
       # Mapping
       ##
       class Mapping
-        include DSL::IntrinsicFunctions
+        include DSL::Helpers
 
         attr_reader :items
+        attr_reader :template
 
-        def initialize(name, template)
+        def initialize(name, parent)
           @name = name
-          @template = template
+          @template = parent.template
 
           @items = Smash.new
         end