sfn 1.1.6 → 1.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33cc7d74a1c8f4392f0582809856400ed3853ba7
-  data.tar.gz: 8d8c74ef584bedcf110a8af780b83f0cb8b484e9
+  metadata.gz: 698f214f1cdff652dc16b36120697090de470f87
+  data.tar.gz: 7efbb32522675152516584455f8f317b9816e6f8
 SHA512:
-  metadata.gz: 4806b2694db30ba48e71aaa4c5de7c6c514a930e61529471ad4a3c23561b229086a501146f234356926a52a3c91f5e167db3f82f1158a655e998d059b5955406
-  data.tar.gz: 05fde4e6095043513c2c76cd19d7c72346fdbfb34679cbaec3bea85a810cdf1f8131d8a1bf43d8b60588717c508134ad7580c8fb1d3f6e1c1bef5130f9610c89
+  metadata.gz: 0f2de1bf189064aa4213a6211730d7a0d0760ff613ce5974db6e8957ee7a5301574fcaa15411be1235ca7c7f9f251bd34c9274288d809f1683f540ffa85c7a71
+  data.tar.gz: c268b90db20e18cb7534ef63b19883026d73e47e62d3cffcfae0d894cb7ad41d58032c715d172d0005f772212250803595c62b06eb9253b92d210ae75940b141

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## v1.1.8
+* [fix] Disable knife config mashing to get expected values (#72)
+* [feature] Add new `conf` command (#72)
+* [feature] Add planning support for stack updates (#69)
+
 ## v1.1.6
 * [fix] set proper parameter hash on apply stack (#67)
 

data/docs/usage.md

@@ -112,6 +112,7 @@ These commands are used for inspection or removal of existing stacks:
 
 * `sfn describe`
 * `sfn inspect`
+* `sfn diff`
 * `sfn events`
 * `sfn destroy`
 

data/lib/chef/knife/knife_plugin_seed.rb

@@ -63,6 +63,7 @@ unless(defined?(Chef::Knife::CloudformationCreate))
             base[k]
           end.compact.first || {}
           cmd_config = cmd_config.to_smash
+
           reconfig = config.find_all do |k,v|
             !v.nil?
           end
@@ -73,11 +74,16 @@ unless(defined?(Chef::Knife::CloudformationCreate))
             end
             [k,v]
           end
-          config = Smash[reconfig]
-          cmd_config = cmd_config.deep_merge(config)
+          n_config = Smash[reconfig]
+          cmd_config = cmd_config.deep_merge(n_config)
           self.class.sfn_class.new(cmd_config, name_args).execute!
         end
 
+        # NOOP this merge as it breaks expected state
+        def merge_configs
+          config
+        end
+
       end
       knife_klass.instance_variable_set(:@name, "Chef::Knife::#{command_class}")
       knife_klass.instance_variable_set(

data/lib/sfn.rb

@@ -14,5 +14,6 @@ module Sfn
   autoload :Knife, 'sfn/knife'
   autoload :Command, 'sfn/command'
   autoload :CommandModule, 'sfn/command_module'
+  autoload :Planner, 'sfn/planner'
 
 end

data/lib/sfn/callback.rb

@@ -17,10 +17,10 @@ module Sfn
 
     # Create a new callback instance
     #
-    # @param [Bogo::Ui]
-    # @param [Smash] configuration hash
-    # @param [Array<String>] arguments from the CLI
-    # @param [Provider] API connection
+    # @param ui [Bogo::Ui]
+    # @param config [Smash] configuration hash
+    # @param arguments [Array<String>] arguments from the CLI
+    # @param api [Provider] API connection
     #
     # @return [self]
     def initialize(ui, config, arguments, api)

data/lib/sfn/command.rb

@@ -4,6 +4,9 @@ require 'bogo-cli'
 module Sfn
   class Command < Bogo::Cli::Command
 
+    include CommandModule::Callbacks
+
+    autoload :Conf, 'sfn/command/conf'
     autoload :Create, 'sfn/command/create'
     autoload :Describe, 'sfn/command/describe'
     autoload :Destroy, 'sfn/command/destroy'

data/lib/sfn/command/conf.rb

@@ -0,0 +1,39 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Config command
+    class Conf < Command
+
+      # Run the list command
+      def execute!
+        ui.info ui.color("Current configuration state:")
+        Config::Conf.attributes.sort_by(&:first).each do |k, val|
+          if(config.has_key?(k))
+            ui.print "  #{ui.color(k, :bold, :green)}: "
+            format_value(config[k], '  ')
+          end
+        end
+      end
+
+      def format_value(value, indent='')
+        if(value.is_a?(Hash))
+          ui.puts
+          value.sort_by(&:first).each do |k,v|
+            ui.print "#{indent}  #{ui.color(k, :bold)}: "
+            format_value(v, indent + '  ')
+          end
+        elsif(value.is_a?(Array))
+          ui.puts
+          value.map(&:to_s).sort.each do |v|
+            ui.print "#{indent}  "
+            format_value(v, indent + '  ')
+          end
+        else
+          ui.puts value.to_s
+        end
+      end
+
+    end
+  end
+end

data/lib/sfn/command/update.rb

@@ -76,14 +76,42 @@ module Sfn
               ui.puts _format_json(translate_template(file))
               return
             end
+
+            original_template = stack.template
+            original_parameters = stack.parameters
+
             stack.template = translate_template(file)
             apply_stacks!(stack)
+
             populate_parameters!(file, :current_parameters => stack.parameters)
+            update_template = stack.template
+
+            if(config[:plan])
+              stack.template = original_template
+              stack.parameters = original_parameters
+              plan = build_planner(stack)
+              if(plan)
+                result = plan.generate_plan(file, config_root_parameters)
+                display_plan_information(result)
+              end
+            end
+
             stack.parameters = config_root_parameters
-            stack.template = Sfn::Utils::StackParameterScrubber.scrub!(stack.template)
+            stack.template = Sfn::Utils::StackParameterScrubber.scrub!(update_template)
           else
             apply_stacks!(stack)
+
+            original_parameters = stack.parameters
             populate_parameters!(stack.template, :current_parameters => stack.parameters)
+
+            if(config[:plan])
+              stack.parameters = original_parameters
+              plan = Planner::Aws.new(ui, config, arguments, stack)
+              if(plan)
+                result = plan.generate_plan(stack.template, config_root_parameters)
+                display_plan_information(result)
+              end
+            end
             stack.parameters = config_root_parameters
           end
 
@@ -115,6 +143,103 @@ module Sfn
         end
       end
 
+      def build_planner(stack)
+        klass_name = stack.api.class.to_s.split('::').last
+        klass = Planner.const_get(klass_name)
+        if(klass)
+          klass.new(ui, config, arguments, stack)
+        else
+          warn "Failed to build planner for current provider. No provider implemented. (`#{klass_name}`)"
+          nil
+        end
+      end
+
+      def display_plan_information(result)
+        ui.info ui.color('Pre-update resource planning report:', :bold)
+        unless(print_plan_result(result))
+          ui.info 'No resources life cycle changes detected in this update!'
+        end
+        ui.confirm 'Apply this stack update?'
+      end
+
+
+      def print_plan_result(info, names=[])
+        said_things = false
+        unless(info[:stacks].empty?)
+          info[:stacks].each do |s_name, s_info|
+            said_things = print_plan_result(s_info, [*names, s_name].compact)
+          end
+        end
+        unless(names.flatten.compact.empty?)
+          ui.puts
+          ui.puts "  #{ui.color('Update plan for:', :bold)} #{ui.color(names.join(' > '), :blue)}"
+          unless(info[:unknown].empty?)
+            ui.puts "    #{ui.color('!!! Unknown update effect:', :red, :bold)}"
+            print_plan_items(info, :unknown, :red)
+            ui.puts
+            said_things = true
+          end
+          unless(info[:unavailable].empty?)
+            ui.puts "    #{ui.color('Update request not allowed:', :red, :bold)}"
+            print_plan_items(info, :unavailable, :red)
+            ui.puts
+            said_things = true
+          end
+          unless(info[:replace].empty?)
+            ui.puts "    #{ui.color('Resources to be replaced:', :red, :bold)}"
+            print_plan_items(info, :replace, :red)
+            ui.puts
+            said_things = true
+          end
+          unless(info[:interrupt].empty?)
+            ui.puts "    #{ui.color('Resources to be interrupted:', :yellow, :bold)}"
+            print_plan_items(info, :interrupt, :yellow)
+            ui.puts
+            said_things = true
+          end
+          unless(info[:removed].empty?)
+            ui.puts "    #{ui.color('Resources to be removed:', :red, :bold)}"
+            print_plan_items(info, :removed, :red)
+            ui.puts
+            said_things = true
+          end
+          unless(info[:added].empty?)
+            ui.puts "    #{ui.color('Resources to be added:', :green, :bold)}"
+            print_plan_items(info, :added, :green)
+            ui.puts
+            said_things = true
+          end
+          unless(said_things)
+            ui.puts "    #{ui.color('No resource lifecycle changes detected!', :green)}"
+            ui.puts
+          end
+        end
+        said_things
+      end
+
+      # Print planning items
+      #
+      # @param info [Hash] plan
+      # @param key [Symbol] key of items
+      # @param color [Symbol] color to flag
+      def print_plan_items(info, key, color)
+        max_name = info[key].keys.map(&:size).max
+        max_type = info[key].values.map{|i|i[:type]}.map(&:size).max
+        info[key].each do |name, val|
+          ui.print ' ' * 6
+          ui.print ui.color("[#{val[:type]}]", color)
+          ui.print ' ' * (max_type - val[:type].size)
+          ui.print ' ' * 4
+          ui.print ui.color(name, :bold)
+          unless(val[:properties].nil? || val[:properties].empty?)
+            ui.print ' ' * (max_name - name.size)
+            ui.print ' ' * 4
+            ui.print "Reason: Updated properties: `#{val[:properties].join('`, `')}`"
+          end
+          ui.puts
+        end
+      end
+
     end
   end
 end

data/lib/sfn/command_module/stack.rb

@@ -123,11 +123,6 @@ module Sfn
             stack_parameters = sparkle.fetch('Parameters', Smash.new)
           end
           unless(stack_parameters.empty?)
-            if(sparkle.is_a?(SparkleFormation))
-              ui.info "#{ui.color('Stack runtime parameters:', :bold)} - template: #{ui.color(sparkle.root_path.map(&:name).map(&:to_s).join(' > '), :green, :bold)}"
-            else
-              ui.info ui.color('Stack runtime parameters:', :bold)
-            end
             if(config.get(:parameter).is_a?(Array))
               config[:parameter] = Smash[
                 *config.get(:parameter).map(&:to_a).flatten
@@ -140,6 +135,7 @@ module Sfn
             else
               config.set(:parameters, config.fetch(:parameter, Smash.new))
             end
+            param_banner = false
             stack_parameters.each do |k,v|
               ns_k = (parameter_prefix + [k]).compact.join('__')
               next if config[:parameters][ns_k]
@@ -167,6 +163,14 @@ module Sfn
                 end
               end
               attempt = 0
+              if(!valid && !param_banner)
+                if(sparkle.is_a?(SparkleFormation))
+                  ui.info "#{ui.color('Stack runtime parameters:', :bold)} - template: #{ui.color(sparkle.root_path.map(&:name).map(&:to_s).join(' > '), :green, :bold)}"
+                else
+                  ui.info ui.color('Stack runtime parameters:', :bold)
+                end
+                param_banner = true
+              end
               until(valid)
                 attempt += 1
                 default = config[:parameters].fetch(

data/lib/sfn/command_module/template.rb

@@ -139,11 +139,13 @@ module Sfn
                 if(formation.compile_state)
                   current_state = current_state.merge(formation.compile_state)
                 end
-                ui.info "#{ui.color('Compile time parameters:', :bold)} - template: #{ui.color(pathed_name, :green, :bold)}" unless config[:print_only]
-                formation.parameters.each do |k,v|
-                  current_state[k] = request_compile_parameter(k, v, current_state[k], !!formation.parent)
+                unless(formation.parameters.empty?)
+                  ui.info "#{ui.color('Compile time parameters:', :bold)} - template: #{ui.color(pathed_name, :green, :bold)}" unless config[:print_only]
+                  formation.parameters.each do |k,v|
+                    current_state[k] = request_compile_parameter(k, v, current_state[k], !!formation.parent)
+                  end
+                  formation.compile_state = current_state
                 end
-                formation.compile_state = current_state
               end
               sparkle_packs.each do |pack|
                 sf.sparkle.add_sparkle(pack)
@@ -197,7 +199,9 @@ module Sfn
             if(config[:print_only])
               template_url = "http://example.com/bucket/#{name_args.first}_#{stack_name}.json"
             else
-              resource.properties.delete!(:stack)
+              unless(config[:plan])
+                resource.properties.delete!(:stack)
+              end
               unless(bucket)
                 raise "Failed to locate configured bucket for stack template storage (#{bucket})!"
               end
@@ -241,7 +245,9 @@ module Sfn
                   :current_parameters => current_parameters
                 )
               )
-              resource.properties.delete!(:stack)
+              unless(config[:plan])
+                resource.properties.delete!(:stack)
+              end
               bucket = provider.connection.api_for(:storage).buckets.get(
                 config[:nesting_bucket]
               )

data/lib/sfn/config.rb

@@ -9,6 +9,7 @@ module Sfn
     # Only values allowed designating bool type
     BOOLEAN_VALUES = [TrueClass, FalseClass]
 
+    autoload :Conf, 'sfn/config/conf'
     autoload :Create, 'sfn/config/create'
     autoload :Describe, 'sfn/config/describe'
     autoload :Destroy, 'sfn/config/destroy'
@@ -67,6 +68,7 @@ module Sfn
       :description => 'Automatically accept any requests for confirmation'
     )
 
+    attribute :conf, Conf, :coerce => proc{|v| Conf.new(v)}
     attribute :create, Create, :coerce => proc{|v| Create.new(v)}
     attribute :update, Update, :coerce => proc{|v| Update.new(v)}
     attribute :destroy, Destroy, :coerce => proc{|v| Destroy.new(v)}

data/lib/sfn/config/conf.rb

@@ -0,0 +1,9 @@
+require 'sfn'
+
+module Sfn
+  class Config
+    # Config command configuration (subclass create to get all the configs)
+    class Conf < Create
+    end
+  end
+end

data/lib/sfn/config/create.rb

@@ -28,6 +28,10 @@ module Sfn
         :multiple => true,
         :description => 'Notification endpoints for stack events'
       )
+      attribute(
+        :plan, FalseClass,
+        :default => false
+      )
 
     end
   end

data/lib/sfn/config/update.rb

@@ -18,6 +18,11 @@ module Sfn
           v.is_a?(String) ? Smash[*v.split(/[=:]/, 2)] : v
         }
       )
+      attribute(
+        :plan, [TrueClass, FalseClass],
+        :default => true,
+        :description => 'Provide planning information prior to update'
+      )
 
     end
   end

data/lib/sfn/planner.rb

@@ -0,0 +1,44 @@
+require 'sfn'
+
+module Sfn
+  # Interface for generating plan report
+  class Planner
+
+    autoload :Aws, 'sfn/planner/aws'
+
+    # @return [Bogo::Ui]
+    attr_reader :ui
+    # @return [Smash]
+    attr_reader :config
+    # @return [Array<String>] CLI arguments
+    attr_reader :arguments
+    # @return [Miasma::Models::Orchestration::Stack] existing remote stack
+    attr_reader :origin_stack
+
+    # Create a new planner instance
+    #
+    # @param ui [Bogo::Ui]
+    # @param config [Smash]
+    # @param arguments [Array<String>]
+    # @param stack [Miasma::Models::Orchestration::Stack]
+    #
+    # @return [self]
+    def initialize(ui, config, arguments, stack)
+      @ui = ui
+      @config = config
+      @arguments = arguments
+      @origin_stack = stack
+    end
+
+    # Generate update report
+    #
+    # @param template [Hash] updated template
+    # @param parameters [Hash] runtime parameters for update
+    #
+    # @return [Hash] report
+    def generate_plan(template, parameters)
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/sfn/planner/aws.rb

@@ -0,0 +1,410 @@
+require 'pp'
+
+
+require 'sfn'
+require 'sparkle_formation/aws'
+require 'hashdiff'
+
+module Sfn
+  class Planner
+    # AWS specific planner
+    class Aws < Planner
+
+      # Customized translator to dereference template
+      class Translator < SparkleFormation::Translation
+
+        # @return [Array<String>] flagged items for value replacement
+        attr_reader :flagged
+
+        # Override to init flagged array
+        def initialize(*_)
+          super
+          @flagged = []
+        end
+
+        # Flag a reference as modified
+        #
+        # @param ref_name [String]
+        # @return [Array<String>]
+        def flag_ref(ref_name)
+          @flagged << ref_name.to_s
+          @flagged.uniq!
+        end
+
+        # Check if resource name is flagged
+        #
+        # @param name [String]
+        # @return [TrueClass, FalseClass]
+        def flagged?(name)
+          @flagged.include?(name.to_s)
+        end
+
+        # Apply function if possible
+        #
+        # @param hash [Hash]
+        # @param funcs [Array] allowed functions
+        # @return [Hash]
+        # @note also allows 'Ref' within funcs to provide mapping
+        #   replacements using the REF_MAPPING constant
+        def apply_function(hash, funcs=[])
+          k,v = hash.first
+          if(hash.size == 1 && (k.start_with?('Fn') || k == 'Ref') && (funcs.empty? || funcs.include?(k)))
+            case k
+            when 'Fn::Join'
+              v.last.join(v.first)
+            when 'Fn::FindInMap'
+              map_holder = mappings[v[0]]
+              if(map_holder)
+                map_item = map_holder[dereference(v[1])]
+                if(map_item)
+                  map_item[v[2]]
+                else
+                  raise "Failed to find mapping item! (#{v[0]} -> #{v[1]})"
+                end
+              else
+                raise "Failed to find mapping! (#{v[0]})"
+              end
+            when 'Fn::GetAtt'
+              func.include?('DEREF') ? dereference(hash) : hash
+            when 'Ref'
+              if(funcs.include?('DEREF'))
+                dereference(hash)
+              else
+                {'Ref' => self.class.const_get(:REF_MAPPING).fetch(v, v)}
+              end
+            else
+              hash
+            end
+          else
+            hash
+          end
+        end
+
+        # Override the parent dereference behavior to return junk
+        # value on flagged resource match
+        #
+        # @param hash [Hash]
+        # @return [Hash, String]
+        def dereference(hash)
+          result = nil
+          if(hash.is_a?(Hash))
+            if(hash.keys.first == 'Ref' && flagged?(hash.values.first))
+              result = '__MODIFIED_REFERENCE_VALUE__'
+            elsif(hash.keys.first == 'Fn::GetAtt')
+              if(hash.values.last.last.start_with?('Outputs.'))
+                if(flagged?(hash.values.join('_')))
+                  result = '__MODIFIED_REFERENCE_VALUE__'
+                end
+              elsif(flagged?(hash.values.first))
+                result = '__MODIFIED_REFERENCE_VALUE__'
+              end
+            end
+          end
+          result.nil? ? super : result
+        end
+
+      end
+
+      # Resources that will be replaced on metadata init updates
+      REPLACE_ON_CFN_INIT_UPDATE = [
+        'AWS::AutoScaling::LaunchConfiguration'
+      ]
+
+      # @return [Smash] initialized translators
+      attr_accessor :translators
+
+      # Simple overload to load in aws resource set from
+      # sparkleformation
+      def initialize(*_)
+        super
+        SfnAws.load!
+        @translators = Smash.new
+      end
+
+      # Generate update report
+      #
+      # @param template [Hash] updated template
+      # @param parameters [Hash] runtime parameters for update
+      #
+      # @return [Hash] report
+      def generate_plan(template, parameters)
+        Smash.new(
+          :stacks => Smash.new(
+            origin_stack.name => plan_stack(
+              origin_stack,
+              template,
+              parameters
+            )
+          ),
+          :added => Smash.new,
+          :removed => Smash.new,
+          :replace => Smash.new,
+          :interrupt => Smash.new,
+          :unavailable => Smash.new,
+          :unknown => Smash.new
+        )
+      end
+
+      protected
+
+      # Generate plan for stack
+      #
+      # @param stack [Miasma::Models::Orchestration::Stack]
+      # @param new_template [Hash]
+      # @param new_parameters [Hash]
+      # @return [Hash]
+      def plan_stack(stack, new_template, new_parameters)
+        plan_results = Smash.new(
+          :stacks => Smash.new,
+          :added => Smash.new,
+          :removed => Smash.new,
+          :replace => Smash.new,
+          :interrupt => Smash.new,
+          :unavailable => Smash.new,
+          :unknown => Smash.new,
+          :outputs => Smash.new,
+          :n_outputs => []
+        )
+
+        origin_template = dereference_template("#{stack.data.checksum}_origin", stack.template, stack.parameters)
+
+        t_key = "#{stack.data.checksum}_#{stack.data.fetch(:logical_id, stack.name)}"
+        run_stack_diff(stack, t_key, plan_results, origin_template, new_template, new_parameters)
+
+        new_checksum = nil
+        current_checksum = false
+        until(new_checksum == current_checksum)
+          current_checksum = plan_results.checksum
+          run_stack_diff(stack, t_key, plan_results, origin_template, new_template, new_parameters)
+          new_checksum = plan_results.checksum
+        end
+        scrub_plan(plan_results)
+        plan_results
+      end
+
+      # Check if resource type is stack resource type
+      #
+      # @param type [String]
+      # @return [TrueClass, FalseClass]
+      def is_stack?(type)
+        origin_stack.api.data.fetch(:stack_types, ['AWS::CloudFormation::Stack']).include?(type)
+      end
+
+      # Scrub the plan results to only provide highest precedence diff
+      # items
+      #
+      # @param results [Hash]
+      # @return [NilClass]
+      def scrub_plan(results)
+        precedence = [:unavailable, :replace, :interrupt, :unavailable, :unknown]
+        until(precedence.empty?)
+          key = precedence.shift
+          results[key].keys.each do |k|
+            precedence.each do |p_key|
+              results[p_key].delete(k)
+            end
+          end
+        end
+        nil
+      end
+
+      # Run the stack diff and populate the result set
+      #
+      # @param stack [Miasma::Models::Orchestration::Stack] existing stack
+      # @param plan_result [Smash] plan data to populate
+      # @param origin_template [Smash] template of existing stack
+      # @param new_template [Smash] template to replace existing
+      # @param new_parameters [Smash] parameters to be applied to update
+      # @return [NilClass]
+      def run_stack_diff(stack, t_key, plan_results, origin_template, new_template, new_parameters)
+        translator = translator_for(t_key)
+
+        new_parameters = new_parameters.dup
+        stack.parameters.each do |k,v|
+          if(new_parameters[k].is_a?(Hash))
+            val = translator.dereference(new_parameters[k])
+            new_parameters[k] = val == new_parameters[k] ? v : val
+          end
+        end
+
+        update_template = dereference_template(
+          t_key, new_template.to_smash, new_parameters,
+          plan_results[:replace].keys + plan_results[:unavailable].keys
+        )
+
+        o_nested_stacks = origin_template['Resources'].find_all do |s_name, s_val|
+          is_stack?(s_val['Type'])
+        end.map(&:first)
+        n_nested_stacks = new_template['Resources'].find_all do |s_name, s_val|
+          is_stack?(s_val['Type'])
+        end.map(&:first)
+        [o_nested_stacks + n_nested_stacks].flatten.compact.uniq.each do |n_name|
+          o_stack = stack.nested_stacks(false).detect{|s| s.data[:logical_id] == n_name}
+          n_exists = is_stack?(update_template['Resources'].fetch(n_name, {})['Type'])
+          n_template = update_template['Resources'].fetch(n_name, {}).fetch('Properties', {})['Stack']
+          n_parameters = update_template['Resources'].fetch(n_name, {}).fetch('Properties', {})['Parameters']
+          n_type = update_template['Resources'].fetch(n_name, {}).fetch('Type',
+            origin_template['Resources'][n_name]['Type']
+          )
+          resource = Smash.new(
+            :name => n_name,
+            :type => n_type,
+            :properties => []
+          )
+          if(o_stack && n_template)
+            n_parameters.keys.each do |n_key|
+              n_parameters[n_key] = translator.dereference(n_parameters[n_key])
+            end
+            n_results = plan_stack(o_stack, n_template, n_parameters)
+            unless(n_results[:outputs].empty?)
+              n_results[:outputs].keys.each do |n_output|
+                translator.flag_ref("#{n_name}_Outputs.#{n_output}")
+              end
+            end
+            plan_results[:stacks][n_name] = n_results
+          elsif(o_stack && (!n_template && !n_exists))
+            plan_results[:removed][n_name] = resource
+          elsif(n_template && !o_stack)
+            plan_results[:added][n_name] = resource
+          end
+        end
+        n_nested_stacks.each do |ns_name|
+          update_template['Resources'][ns_name]['Properties'].delete('Stack')
+        end
+        HashDiff.diff(origin_template, MultiJson.load(MultiJson.dump(update_template))).group_by do |item|
+          item[1]
+        end.each do |a_path, diff_items|
+          register_diff(
+            plan_results, a_path, diff_items, translator_for(t_key),
+            :origin => origin_template,
+            :update => update_template
+          )
+        end
+        nil
+      end
+
+      # Register a diff item into the results set
+      #
+      # @param results [Hash]
+      # @param path [String]
+      # @param diff [Array]
+      # @param templates [Hash]
+      # @option :templates [Hash] :origin
+      # @option :templates [Hash] :update
+      def register_diff(results, path, diff, translator, templates)
+        if(path.start_with?('Resources'))
+          p_path = path.split('.')
+          if(p_path.size == 2)
+            diff = diff.first
+            key = diff.first == '+' ? :added : :removed
+            type = (key == :added ? templates[:update] : templates[:origin])['Resources'][p_path.last]['Type']
+            results[key][p_path.last] = Smash.new(
+              :name => p_path.last,
+              :type => type,
+              :properties => []
+            )
+          else
+            if(p_path.include?('Properties'))
+              resource_name = p_path[1]
+              property_name = p_path[3].sub(/\[\d+\]$/, '')
+              type = templates[:origin]['Resources'][resource_name]['Type']
+              info = SfnAws.registry[type]
+              effect = info[:full_properties].fetch(property_name, {}).fetch(:update_causes, :unknown)
+              resource = Smash.new(
+                :name => resource_name,
+                :type => type,
+                :properties => [property_name]
+              )
+              case effect
+              when :replacement
+                set_resource(:replace, results, resource_name, resource)
+              when :interrupt
+                set_resource(:interrupt, results, resource_name, resource)
+              when :unavailable
+                set_resource(:unavailable, results, resource_name, resource)
+              when :none
+                # \o/
+              else
+                set_resource(:unknown, results, resource_name, resource)
+              end
+            elsif(p_path.include?('AWS::CloudFormation::Init'))
+              resource_name = p_path[1]
+              type = templates[:origin]['Resources'][resource_name]['Type']
+              if(REPLACE_ON_CFN_INIT_UPDATE.include?(type))
+                set_resource(:replace, results, resource_name,
+                  Smash.new(
+                    :name => resource_name,
+                    :type => type,
+                    :properties => ['AWS::CloudFormation::Init']
+                  )
+                )
+              end
+            end
+          end
+        elsif(path.start_with?('Outputs'))
+          set_resource(:outputs, results, path.split('.')[1], {:properties => []})
+        end
+      end
+
+      # Set resource item into result set
+      #
+      # @param kind [Symbol]
+      # @param results [Hash]
+      # @param name [String]
+      # @param resource [Hash]
+      def set_resource(kind, results, name, resource)
+        if(results[kind][name])
+          results[kind][name][:properties] += resource[:properties]
+          results[kind][name][:properties].uniq!
+        else
+          results[kind][name] = resource
+        end
+      end
+
+      # Dereference all parameters within template to allow for
+      # processing using real values
+      #
+      # @param t_key [String]
+      # @param template [Hash]
+      # @param parameters [Hash]
+      # @param flagged [Array<String>]
+      #
+      # @return [Hash]
+      def dereference_template(t_key, template, parameters, flagged=[])
+        translator = translator_for(t_key, template, parameters)
+        flagged.each do |item|
+          translator.flag_ref(item)
+        end
+        template['Resources'] = translator.dereference_processor(template['Resources'], ['Ref', 'Fn', 'DEREF'])
+        template['Outputs'] = translator.dereference_processor(template['Outputs'], ['Ref', 'Fn', 'DEREF'])
+        template
+      end
+
+      # Provide a translator instance for given key (new or cached instance)
+      #
+      # @param t_key [String] identifier
+      # @param template [Hash] stack template
+      # @param parameters [Hash] stack parameters
+      # @return [Translator]
+      def translator_for(t_key, template=nil, parameters=nil)
+        o_translator = translators[t_key]
+        if(template)
+          translator = Translator.new(template, :parameters => parameters)
+          if(o_translator)
+            o_translator.flagged.each do |i|
+              translator.flag_ref(i)
+            end
+          end
+          translators[t_key] = translator
+          o_translator = translator
+        else
+          unless(o_translator)
+            o_translator = Translator.new({}, :parameters => {})
+          end
+        end
+        o_translator
+      end
+
+    end
+  end
+end

data/lib/sfn/version.rb

@@ -1,4 +1,4 @@
 module Sfn
   # Current library version
-  VERSION = Gem::Version.new('1.1.6')
+  VERSION = Gem::Version.new('1.1.8')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sfn
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.1.8
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-30 00:00:00.000000000 Z
+date: 2015-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo-cli
@@ -124,6 +124,7 @@ files:
 - lib/sfn/callback.rb
 - lib/sfn/callback/stack_policy.rb
 - lib/sfn/command.rb
+- lib/sfn/command/conf.rb
 - lib/sfn/command/create.rb
 - lib/sfn/command/describe.rb
 - lib/sfn/command/destroy.rb
@@ -143,6 +144,7 @@ files:
 - lib/sfn/command_module/stack.rb
 - lib/sfn/command_module/template.rb
 - lib/sfn/config.rb
+- lib/sfn/config/conf.rb
 - lib/sfn/config/create.rb
 - lib/sfn/config/describe.rb
 - lib/sfn/config/destroy.rb
@@ -158,6 +160,8 @@ files:
 - lib/sfn/config/validate.rb
 - lib/sfn/monkey_patch.rb
 - lib/sfn/monkey_patch/stack.rb
+- lib/sfn/planner.rb
+- lib/sfn/planner/aws.rb
 - lib/sfn/provider.rb
 - lib/sfn/utils.rb
 - lib/sfn/utils/debug.rb