sparkle_formation 2.1.8 → 3.0.0

data/lib/sparkle_formation/provider/azure.rb

@@ -26,7 +26,7 @@ class SparkleFormation
       # @yieldparam resource [AttributeStruct] the stack resource
       # @yieldparam s_name [String] stack resource name
       # @yieldreturn [Hash] key/values to be merged into resource properties
-      # @return [Hash] dumped stack
+      # @return [SparkleFormation::SparkleStruct] compiled structure
       def apply_deep_nesting(*args, &block)
         outputs = collect_outputs
         nested_stacks(:with_resource).each do |stack, resource|
@@ -44,7 +44,7 @@ class SparkleFormation
         if(block_given?)
           extract_templates(&block)
         end
-        compile.dump!
+        compile
       end
 
       # Apply shallow nesting. This style of nesting will bubble
@@ -55,7 +55,7 @@ class SparkleFormation
       # @yieldparam resource_name [String] name of stack resource
       # @yieldparam stack [SparkleFormation] nested stack
       # @yieldreturn [String] Remote URL storage for template
-      # @return [Hash]
+      # @return [SparkleFormation::SparkleStruct] compiled structure
       def apply_shallow_nesting(*args, &block)
         parameters = compile.parameters
         output_map = {}
@@ -68,7 +68,7 @@ class SparkleFormation
             compile.outputs._set(o_name).value compile._stack_output(*o_val)
           end
         end
-        compile.dump!
+        compile
       end
 
       # Extract output to make available for stack parameter usage at the

data/lib/sparkle_formation/provider/google.rb

@@ -0,0 +1,200 @@
+require 'sparkle_formation'
+
+class SparkleFormation
+  module Provider
+    # Google specific implementation
+    module Google
+
+      # Always return as nested since nesting is our final form
+      def nested?(*_)
+        true
+      end
+
+      # Extract nested stack templates and store in root level files
+      #
+      # @param template_hash [Hash] template hash to process
+      # @param dump_copy [Smash] translated dump
+      # @param parent_names [Array<String>] name of parent resources
+      # @return [Smash] dump_copy
+      def google_template_extractor(template_hash, dump_copy, parent_names=[])
+        template_hash.fetch('resources', []).each do |t_resource|
+          if(t_resource['type'] == stack_resource_type)
+            full_names = parent_names + [t_resource['name']]
+            stack = t_resource['properties'].delete('stack')
+            if(t_resource['properties'].empty?)
+              t_resource.delete('properties')
+            end
+            google_template_extractor(stack, dump_copy, full_names)
+            new_type = generate_template_files(full_names.join('-'), stack, dump_copy)
+            t_resource['type'] = new_type
+          end
+        end
+        dump_copy
+      end
+
+      # Sets stack template files into target copy and extracts parameters
+      # into schema files if available
+      #
+      # @param r_name [String] name used for template file name
+      # @param r_stack [Hash] template to store
+      # @param dump_copy [Smash] translated dump
+      # @return [String] new type for stack
+      def generate_template_files(r_name, r_stack, dump_copy)
+        f_name = "#{r_name}.jinja"
+        r_parameters = r_stack.delete('parameters')
+        dump_copy[:imports].push(
+          Smash.new(
+            :name => f_name,
+            :content => r_stack
+          )
+        )
+        if(r_parameters)
+          dump_copy[:imports].push(
+            Smash.new(
+              :name => "#{f_name}.schema",
+              :content => Smash.new.tap{|schema|
+                schema.set(:info, :title, "#{f_name} template")
+                schema.set(:info, :description, "#{f_name} template schema")
+                schema.set(:properties, r_parameters)
+              }
+            )
+          )
+        end
+        f_name
+      end
+
+      # Customized dump to break out templates into consumable structures for
+      # passing to the deployment manager API
+      #
+      # @return [Hash]
+      def google_dump
+        result = non_google_dump
+        if(root?)
+          dump_copy = Smash.new(:imports => [])
+          google_template_extractor(result, dump_copy)
+          dump_copy.set(:config, :content, result)
+          dump_copy.set(:config, :content, :imports,
+            dump_copy[:imports].map{|i| i[:name]}
+          )
+          dump_copy.to_hash
+        else
+          result
+        end
+      end
+
+      # Properly remap dumping methods
+      def self.included(klass)
+        klass.class_eval do
+          alias_method :non_google_dump, :dump
+          alias_method :dump, :google_dump
+        end
+      end
+
+      # Properly remap dumping methods
+      def self.extended(klass)
+        klass.instance_eval do
+          alias :non_google_dump :dump
+          alias :dump :google_dump
+        end
+      end
+
+      # @return [String] Type string for Google Deployment Manager stack resource
+      # @note Nested templates aren't defined as a specific type thus no "real"
+      #   type exists. So we'll create a custom one!
+      def stack_resource_type
+        'sparkleformation.stack'
+      end
+
+      # Generate policy for stack
+      #
+      # @return [Hash]
+      def generate_policy
+        {}
+      end
+
+      # Apply deeply nested stacks. This is the new nesting approach and
+      # does not bubble parameters up to the root stack. Parameters are
+      # isolated to the stack resource itself and output mapping is
+      # automatically applied.
+      #
+      # @yieldparam stack [SparkleFormation] stack instance
+      # @yieldparam resource [AttributeStruct] the stack resource
+      # @yieldparam s_name [String] stack resource name
+      # @yieldreturn [Hash] key/values to be merged into resource properties
+      # @return [SparkleFormation::SparkleStruct] compiled structure
+      def apply_deep_nesting(*args, &block)
+        outputs = collect_outputs
+        nested_stacks(:with_resource).each do |stack, resource|
+          unless(stack.nested_stacks.empty?)
+            stack.apply_deep_nesting(*args)
+          end
+          stack.compile.parameters.keys!.each do |parameter_name|
+            if(output_name = output_matched?(parameter_name, outputs.keys))
+              next if outputs[output_name] == stack
+              stack_output = stack.make_output_available(output_name, outputs, self)
+              # NOTE: Only set value if not already explicitly set
+              if(resource.properties._set(parameter_name).nil?)
+                resource.properties._set(parameter_name, stack_output)
+              end
+            end
+          end
+        end
+        if(block_given?)
+          extract_templates(&block)
+        end
+        self
+      end
+
+      # Forcibly disable shallow nesting as support for it with Google templates doesn't
+      # really make much sense.
+      def apply_shallow_nesting(*args, &block)
+        raise NotImplementedError.new 'Shallow nesting is not supported for this provider!'
+      end
+
+      # Extract output to make available for stack parameter usage at the
+      # current depth
+      #
+      # @param output_name [String] name of output
+      # @param outputs [Hash] listing of outputs
+      # @param source_stack [SparkleFormation] requesting stack
+      # @reutrn [Hash] reference to output value (used for setting parameter)
+      def make_output_available(output_name, outputs, source_stack)
+        bubble_path = outputs[output_name].root_path - root_path
+        drip_path = root_path - outputs[output_name].root_path
+        bubble_path.each_slice(2) do |base_sparkle, ref_sparkle|
+          next unless ref_sparkle
+          base_sparkle.compile.outputs._set(output_name)._set(
+            :value, base_sparkle.compile._stack_output(
+              ref_sparkle.name, output_name
+            )
+          )
+        end
+        if(bubble_path.empty?)
+          if(drip_path.size == 1)
+            parent = drip_path.first.parent
+            if(parent && !parent.compile.parameters._set(output_name).nil?)
+              return compile.parameter!(output_name)
+            end
+          end
+          raise ArgumentError.new "Failed to detect available bubbling path for output `#{output_name}`. " <<
+            'This may be due to a circular dependency! ' <<
+            "(Output Path: #{outputs[output_name].root_path.map(&:name).join(' > ')} " <<
+            "Requester Path: #{root_path.map(&:name).join(' > ')})"
+        end
+        result = source_stack.compile._stack_output(bubble_path.first.name, output_name)
+        if(drip_path.size > 1)
+          parent = drip_path.first.parent
+          drip_path.unshift(parent) if parent
+          drip_path.each_slice(2) do |base_sparkle, ref_sparkle|
+            next unless ref_sparkle
+            base_sparkle.compile.resources[ref_sparkle.name].properties.parameters.value._set(output_name, result)
+            ref_sparkle.compile.parameters._set(output_name).type 'string' # TODO: <<<<------ type check and prop
+            result = compile._parameter(output_name)
+          end
+        end
+        result
+      end
+
+    end
+  end
+end

data/lib/sparkle_formation/provider/heat.rb

@@ -26,7 +26,7 @@ class SparkleFormation
       # @yieldparam resource [AttributeStruct] the stack resource
       # @yieldparam s_name [String] stack resource name
       # @yieldreturn [Hash] key/values to be merged into resource properties
-      # @return [Hash] dumped stack
+      # @return [SparkleFormation::SparkleStruct] compiled structure
       def apply_deep_nesting(*args, &block)
         outputs = collect_outputs
         nested_stacks(:with_resource).each do |stack, resource|
@@ -44,7 +44,7 @@ class SparkleFormation
         if(block_given?)
           extract_templates(&block)
         end
-        compile.dump!
+        compile
       end
 
       # Apply shallow nesting. This style of nesting will bubble
@@ -55,7 +55,7 @@ class SparkleFormation
       # @yieldparam resource_name [String] name of stack resource
       # @yieldparam stack [SparkleFormation] nested stack
       # @yieldreturn [String] Remote URL storage for template
-      # @return [Hash]
+      # @return [SparkleFormation::SparkleStruct] compiled structure
       def apply_shallow_nesting(*args, &block)
         parameters = compile.parameters
         output_map = {}
@@ -68,7 +68,7 @@ class SparkleFormation
             compile.outputs._set(o_name).value compile._stack_output(*o_val)
           end
         end
-        compile.dump!
+        compile
       end
 
       # Extract output to make available for stack parameter usage at the

data/lib/sparkle_formation/resources.rb

@@ -6,6 +6,7 @@ class SparkleFormation
 
     autoload :Aws, 'sparkle_formation/resources/aws'
     autoload :Azure, 'sparkle_formation/resources/azure'
+    autoload :Google, 'sparkle_formation/resources/google'
     autoload :Heat, 'sparkle_formation/resources/heat'
     autoload :Rackspace, 'sparkle_formation/resources/rackspace'
 
@@ -13,6 +14,64 @@ class SparkleFormation
     RESOURCE_TYPE_TR = '_'
     # String to split for resource namespacing
     RESOURCE_TYPE_NAMESPACE_SPLITTER = '::'
+    # Property update conditionals
+    # Format: Smash.new(RESOURCE_TYPE => {PROPERTY_NAME => [PropertyConditional]})
+    PROPERTY_UPDATE_CONDITIONALS = Smash.new
+
+    # Defines a resource type
+    #
+    # @param name [String] name of resource type
+    # @param properties [Array<Property>] resource properties
+    # @param raw [Hash] raw resource information
+    Resource = Struct.new(:name, :properties, :raw) do
+      # Get property by name
+      #
+      # @param name [String] name of property
+      # @return [Property, NilClass]
+      def property(name)
+        properties.detect do |prop|
+          prop.name == name
+        end
+      end
+    end
+
+    # Defines conditional result for cause of property update
+    #
+    # @param update_causes [String] one of: 'replacement', 'interrupt', 'unknown', 'none'
+    # @param conditional [Proc, TrueClass] condition logic. passed two values: Hash of resource "final" state and
+    #   Hash of resource "original" state
+    UpdateCausesConditional = Struct.new(:update_causes, :conditional)
+
+    # Defines a resource property
+    #
+    # @param name [String] property name
+    # @param description [String] property descrition
+    # @param type [String] property data type
+    # @param required [TrueClass, FalseClass] property is required
+    # @param update_causes [String] one of: 'replacement', 'interrupt', 'unknown', 'none'
+    # @param conditionals [Array<UpdateCausesConditional>] conditionals for update causes
+    Property = Struct.new(:name, :description, :type, :required, :update_causes, :conditionals) do
+      # Determine result of property update
+      #
+      # @param final_resource [Hash] desired resource structure containing this property
+      # @return ['replacement', 'interrupt', 'unknown', 'none']
+      def update_causes(final_resource=nil, original_resource=nil)
+        if(conditionals && final_resource)
+          final_resource = final_resource.to_smash
+          original_resource = original_resource.to_smash
+          result = conditionals.detect do |p_cond|
+            p_cond == true || p_cond.conditional.call(final_resource, original_resource)
+          end
+          if(result)
+            result.update_causes
+          else
+            'unknown'
+          end
+        else
+          self[:update_causes]
+        end
+      end
+    end
 
     class << self
 
@@ -80,27 +139,31 @@ class SparkleFormation
       # @param key [String, Symbol]
       # @return [String, NilClass]
       def registry_key(key)
-        o_key = key
-        key = key.to_s.tr(self.const_get(:RESOURCE_TYPE_TR), '') # rubocop:disable Style/RedundantSelf
-        snake_parts = nil
-        result = @@registry[base_key].keys.detect do |ref|
-          ref = ref.downcase
-          snake_parts = ref.split(resource_type_splitter)
-          until(snake_parts.empty?)
-            break if snake_parts.join('') == key
-            snake_parts.shift
-          end
-          !snake_parts.empty?
-        end
-        if(result)
-          collisions = @@registry[base_key].keys.find_all do |ref|
-            split_ref = ref.downcase.split(resource_type_splitter)
-            ref = split_ref.slice(split_ref.size - snake_parts.size, split_ref.size).join('')
-            key == ref
+        if(registry[key])
+          result = key
+        else
+          o_key = key
+          key = key.to_s.tr(self.const_get(:RESOURCE_TYPE_TR), '') # rubocop:disable Style/RedundantSelf
+          snake_parts = nil
+          result = @@registry[base_key].keys.detect do |ref|
+            ref = ref.downcase
+            snake_parts = ref.split(resource_type_splitter)
+            until(snake_parts.empty?)
+              break if snake_parts.join('') == key
+              snake_parts.shift
+            end
+            !snake_parts.empty?
           end
-          if(collisions.size > 1)
-            raise ArgumentError.new 'Ambiguous dynamic name returned multiple matches! ' \
-              "`#{o_key.inspect}` -> #{collisions.sort.join(', ')}"
+          if(result)
+            collisions = @@registry[base_key].keys.find_all do |ref|
+              split_ref = ref.downcase.split(resource_type_splitter)
+              ref = split_ref.slice(split_ref.size - snake_parts.size, split_ref.size).join('')
+              key == ref
+            end
+            if(collisions.size > 1)
+              raise ArgumentError.new 'Ambiguous dynamic name returned multiple matches! ' \
+                "`#{o_key.inspect}` -> #{collisions.sort.join(', ')}"
+            end
           end
         end
         result
@@ -121,7 +184,7 @@ class SparkleFormation
       # @param key [String, Symbol]
       # @return [Hashish, NilClass]
       def lookup(key)
-        @@registry[base_key][registry_key(key)]
+        @@registry[base_key][key] || @@registry[base_key][registry_key(key)]
       end
 
       # @return [Hashish] currently loaded AWS registry
@@ -142,6 +205,28 @@ class SparkleFormation
         struct
       end
 
+      # Information about specific resource type
+      #
+      # @param type [String] resource type
+      # @return [Resource]
+      def resource_lookup(type)
+        result = registry[type]
+        if(result)
+          properties = result.fetch('full_properties', {}).map do |p_name, p_info|
+            Property.new(p_name,
+              p_info[:description],
+              p_info[:type],
+              p_info[:required],
+              p_info[:update_causes],
+              self.const_get(:PROPERTY_UPDATE_CONDITIONALS).get(type, p_name)
+            )
+          end
+          Resource.new(type, properties, result)
+        else
+          raise KeyError.new "Failed to locate requested resource type: `#{type}`"
+        end
+      end
+
     end
   end
 end

data/lib/sparkle_formation/resources/aws.rb

@@ -8,6 +8,258 @@ class SparkleFormation
     # AWS specific resources collection
     class Aws < Resources
 
+      # Conditionals for property updates
+      PROPERTY_UPDATE_CONDITIONALS = Smash.new(
+        'AWS::DynamoDB::Table' => {
+          'GlobalSecondaryIndexes' => [
+            # Updates not really supported here. Set as unknown to
+            # prompt user to investigate
+            UpdateCausesConditional.new('unknown', true)
+          ]
+        },
+        'AWS::EC2::EIPAssociation' => {
+          'AllocationId' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                original.get('Properties', 'InstanceId') != final.get('Properties', 'InstanceId') ||
+                  original.get('Properties', 'NetworkInterfaceId') != final.get('Properties', 'NewtorkInterfaceId')
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'EIP' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                original.get('Properties', 'InstanceId') != final.get('Properties', 'InstanceId') ||
+                  original.get('Properties', 'NetworkInterfaceId') != final.get('Properties', 'NewtorkInterfaceId')
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'InstanceId' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                original.get('Properties', 'AllocationId') != final.get('Properties', 'AllocationId') ||
+                  original.get('Properties', 'EIP') != final.get('Properties', 'EIP')
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'NetworkInterfaceId' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                original.get('Properties', 'AllocationId') != final.get('Properties', 'AllocationId') ||
+                  original.get('Properties', 'EIP') != final.get('Properties', 'EIP')
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ]
+        },
+        'AWS::EC2::Instance' => {
+          'AdditionalInfo' => [
+            UpdateCausesConditional.new('unknown', true) # EBS AMI dependent
+          ],
+          'BlockDeviceMappings' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                f_maps = final.fetch('Properties', 'BlockDeviceMappings', [])
+                o_maps = original.fetch('Properties', 'BlockDeviceMappings', [])
+                f_maps.map! do |m|
+                  m.delete('DeleteOnTermination')
+                  m.to_smash(:sorted)
+                end
+                o_maps.map! do |m|
+                  m.delete('DeleteOnTermination')
+                  m.to_smash(:sorted)
+                end
+                f_maps.size != o_maps.size ||
+                  !f_maps.all?{|m| o_maps.include?(m)}
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'EbsOptimized' => [
+            UpdateCausesConditional.new('unknown', true) # EBS AMI dependent
+          ],
+          'InstanceType' => [
+            UpdateCausesConditional.new('unknown', true) # EBS AMI dependent
+          ],
+          'KernelId' => [
+            UpdateCausesConditional.new('unknown', true) # EBS AMI dependent
+          ],
+          'RamdiskId' => [
+            UpdateCausesConditional.new('unknown', true) # EBS AMI dependent
+          ],
+          'SecurityGroupIds' => [
+            UpdateCausesConditional.new('none',
+              lambda{|final, _orig|
+                final.get('Properties', 'SubnetId') ||
+                  final.fetch('Properties', 'NetworkInterface', {}).values.include?('SubnetId')
+              }
+            ),
+            UpdateCausesConditional.new('replacement', true)
+          ],
+          'UserData' => [
+            UpdateCausesConditional.new('unknown', true) # EBS AMI dependent
+          ]
+        },
+        'AWS::EC2::NetworkInterface' => {
+          'PrivateIpAddresses' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                f_primary = final.fetch('Properties', 'PrivateIpAddresses', []).detect do |addr|
+                  addr['Primary']
+                end || Smash.new
+                o_primary = original.fetch('Properties', 'PrivateIpAddresses', []).detect do |addr|
+                  addr['Primary']
+                end || Smash.new
+                f_primary.to_smash(:sorted) != o_primary.to_smash(:sorted)
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ]
+        },
+        'AWS::ElastiCache::CacheCluster' => {
+          'NumCacheNodes' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                [
+                  final.get('Properties', 'PreferredAvailabilityZone'),
+                  final.get('Properties', 'PreferredAvailabilityZones'),
+                  original.get('Properties', 'PreferredAvailabilityZone'),
+                  original.get('Properties', 'PreferredAvailabilityZones')
+                ].all?{|i| i.nil? || i.empty? }
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'PreferredAvailabilityZones' => [
+            UpdateCausesConditional.new('interrupt',
+              lambda{|final, original|
+                original.get('Properties', 'PreferredAvailabilityZones') ||
+                  final.fetch('Properties', 'PreferredAvailabilityZones', []).include?(
+                    original.get('Properties', 'PreferredAvailabilityZone')
+                )
+              }
+            ),
+            UpdateCausesConditional.new('replacement', true)
+          ]
+        },
+        'AWS::ElasticLoadBalancing::LoadBalancer' => {
+          'AvailabilityZones' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                original.fetch('Properties', 'AvailabilityZones', []).empty? ||
+                  final.fetch('Properties', 'AvailabilityZones', []).empty?
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'HealthCheck' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                original.fetch('Properties', 'HealthCheck', {}).empty? ||
+                  final.fetch('Properties', 'HealthCheck', {}).empty?
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'Subnets' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                original.fetch('Properties', 'Subnets', []).empty? ||
+                  final.fetch('Properties', 'Subnets', []).empty?
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ]
+        },
+        'AWS::RDS::DBCluster' => {
+          'BackupRetentionPeriod' => [
+            UpdateCausesConditional.new('interrupt',
+              lambda{|final, original|
+                fp = final.get('Properties', 'BackupRetentionPeriod').to_i
+                op = original.get('Properties', 'BackupRetentionPeriod').to_i
+                (fp == 0 && op != 0) ||
+                  (op == 0 && fp != 0)
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'PreferredMaintenanceWindow' => [
+            # can interrupt if apply immediately is set on api call but
+            # no way to know
+            UpdateCausesConditional.new('unknown', true)
+          ]
+        },
+        'AWS::RDS::DBClusterParameterGroup' => {
+          'Parameters' => [
+            # dependent on what parameters have been changed. doesn't
+            # look like parameter modifications are applied immediately?
+            # set as unknown for safety
+            UpdateCausesConditional.new('unknown', true)
+          ]
+        },
+        'AWS::RDS::DBInstance' => {
+          'AutoMinorVersionUpgrade' => [
+            # can cause interrupts based on future actions (enables
+            # auto patching) so leave as unknown for safety
+            UpdateCausesConditional.new('unknown', true)
+          ],
+          'BackupRetentionPeriod' => [
+            UpdateCausesConditional.new('interrupt',
+              lambda{|final, original|
+                fp = final.get('Properties', 'BackupRetentionPeriod').to_i
+                op = original.get('Properties', 'BackupRetentionPeriod').to_i
+                (fp == 0 && op != 0) ||
+                  (op == 0 && fp != 0)
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ],
+          'DBParameterGroupName' => [
+            # changes are not applied until reboot, but it could
+            # still be considered an interrupt? setting as unknown
+            # for safety
+            UpdateCausesConditional.new('unknown', true)
+          ],
+          'PreferredMaintenanceWindow' => [
+            # can interrupt if apply immediately is set on api call but
+            # no way to know
+            UpdateCausesConditional.new('unknown', true)
+          ]
+        },
+        'AWS::RDS::DBParameterGroup' => {
+          'Parameters' => [
+            # dependent on what parameters have been changed. doesn't
+            # look like parameter modifications are applied immediately?
+            # set as unknown for safety
+            UpdateCausesConditional.new('unknown', true)
+          ]
+        },
+        'AWS::RDS::EventSubscription' => {
+          'SourceType' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                !final.get('Properties', 'SourceType')
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ]
+        },
+        'AWS::Route53::HostedZone' => {
+          'VPCs' => [
+            UpdateCausesConditional.new('replacement',
+              lambda{|final, original|
+                !final.get('Properties', 'VPCs') ||
+                  !original.get('Properties', 'VPCs')
+              }
+            ),
+            UpdateCausesConditional.new('none', true)
+          ]
+        }
+      )
+
       class << self
 
         include Bogo::Memoization