sfn 2.1.6 → 2.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b2ef775b264c538208dcd1cb1010fe50af9c5fd
-  data.tar.gz: 3043b030b8b16a2a356cdba35b6299497c16ea27
+  metadata.gz: 610903a7a6be9347a5c0d51bff46e3eba9239e28
+  data.tar.gz: 0aacd95b68b649c70416a02c77c8bf06d60072cf
 SHA512:
-  metadata.gz: 3ed7440587bfc33ff5d2224cb3306fdf5dbc5e546a750e5987aa3df3f5ce5788bca5f8738741dc3bdb9e4c893fb21708859897ce18be27be19b44866ffb906e1
-  data.tar.gz: 2946e28dc3e74dfa06cc71b6db2f72e1cbe5a710d28c8406a9f3a596f3ddd43afd78000413a32373bc661f54c4c1221d523512e47889ed47855b79c67be107a5
+  metadata.gz: 3cce4831036082b7f85c80e7d29b9d71aff2ae54b645830030126732642edfac1c10fd3e3a9e36f8bc889666cfd3bdc98f1c1113f948f3d6bc61310834cea2b9
+  data.tar.gz: bb744d8e3639da9440321c325f1f70ce593fa0e748795e0f4184e7dd9ec492345b85956755c83fcafac2227bfdb54b7a45e399715e767b521ca58d7533fb5185

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# v2.1.8
+* [fix] Fix some planner errors caused by unexpected types (#146)
+* [fix] Use common stack scrubbing implementation for create and update (#148)
+* [fix] Properly expand nested stacks when displaying events (#148)
+* [enhancement] Update internal stack data caching to reduce request numbers and size (#148)
+* [feature] Add initial graph command implementation (currenty AWS only) (#152)
+
 # v2.1.6
 * [fix] Prevent configuration defaults overwriting user defined values (#144)
 

data/lib/sfn/command.rb

@@ -13,6 +13,7 @@ module Sfn
     autoload :Diff, 'sfn/command/diff'
     autoload :Events, 'sfn/command/events'
     autoload :Export, 'sfn/command/export'
+    autoload :Graph, 'sfn/command/graph'
     autoload :Import, 'sfn/command/import'
     autoload :Init, 'sfn/command/init'
     autoload :Inspect, 'sfn/command/inspect'

data/lib/sfn/command/create.rb

@@ -59,7 +59,7 @@ module Sfn
           )
 
           apply_stacks!(stack)
-          stack.template = Sfn::Utils::StackParameterScrubber.scrub!(stack.template)
+          stack.template = Sfn::Utils::StackParameterScrubber.scrub!(scrub_template(stack.template))
 
           if(config[:print_only])
             ui.puts _format_json(translate_template(stack.template))

data/lib/sfn/command/events.rb

@@ -15,10 +15,8 @@ module Sfn
         name_required!
         name = name_args.first
         ui.info "Events for Stack: #{ui.color(name, :bold)}\n"
-        @stacks = []
-        @stack = provider.connection.stacks.get(name)
-        @stacks << stack
-        discover_stacks(stack)
+        @seen_events = []
+        @stack = provider.stack(name)
         if(stack)
           api_action!(:api_stack => stack) do
             table = ui.table(self) do
@@ -41,13 +39,13 @@ module Sfn
               end
             end.display
             if(config[:poll])
-              while(stack.in_progress?)
+              while(stack.reload.in_progress?)
                 to_wait = config.fetch(:poll_wait_time, 10).to_f
                 while(to_wait > 0)
                   sleep(0.1)
                   to_wait -= 0.1
                 end
-                stack.reload
+                stack.resources.reload
                 table.display
               end
             end
@@ -64,30 +62,36 @@ module Sfn
       # @param last_id [String] only return events after this ID
       # @return [Array<Hash>]
       def get_events(*args)
-        discover_stacks(stack)
-        stack_events = @stacks.map do |stack|
-          stack.events.all.map do |e|
-            e.attributes.merge(:stack_name => stack.name).to_smash
+        stack_events = discover_stacks(stack).map do |i_stack|
+          i_events = i_stack.events.reload.all
+          i_events.map do |e|
+            e.attributes.merge(:stack_name => i_stack.name).to_smash
           end
-        end.flatten.compact.find_all{|e| e[:time] }
-        stack_events.sort do |x,y|
-          Time.parse(x[:time].to_s) <=> Time.parse(y[:time].to_s)
+        end.flatten.compact.find_all{|e| e[:time] }.reverse
+        stack_events.delete_if{|evt| @seen_events.include?(evt)}
+        @seen_events.concat(stack_events)
+        unless(@initial_complete)
+          stack_events = stack_events.sort_by{|e| e[:time] }
+          unless(config[:all_events])
+            start_index = stack_events.rindex do |item|
+              item[:stack_name] == stack.name &&
+                item[:resource_state].to_s.end_with?('in_progress') &&
+                item[:resource_status_reason].to_s.downcase.include?('user init')
+            end
+            if(start_index)
+              stack_events.slice!(0, start_index)
+            end
+          end
+          @initial_complete = true
         end
+        stack_events
       end
 
       # Discover stacks defined within the resources of given stack
       #
       # @param stack [Miasma::Models::Orchestration::Stack]
       def discover_stacks(stack)
-        stack.resources.reload.all.each do |resource|
-          if(resource.type == 'AWS::CloudFormation::Stack')
-            nested_stack = provider.connection.stacks.get(resource.id)
-            if(nested_stack)
-              @stacks.push(nested_stack).uniq!
-              discover_stacks(nested_stack)
-            end
-          end
-        end
+        @stacks = [stack] + stack.nested_stacks.reverse
       end
 
       # @return [Array<String>] default attributes for events

data/lib/sfn/command/graph.rb

@@ -0,0 +1,228 @@
+require 'sfn'
+require 'graph'
+
+module Sfn
+  class Command
+    # Graph command
+    class Graph < Command
+
+      include Sfn::CommandModule::Base
+      include Sfn::CommandModule::Template
+      include Sfn::CommandModule::Stack
+
+      # Generate graph
+      def execute!
+        config[:print_only] = true
+        file = load_template_file
+        file.delete('sfn_nested_stack')
+        file = Sfn::Utils::StackParameterScrubber.scrub!(file)
+        file = translate_template(file)
+        @outputs = Smash.new
+        file = file.to_smash
+        ui.info 'Template resource graph generation'
+        if(config[:file])
+          ui.puts "  -> path: #{config[:file]}"
+        end
+        run_action 'Pre-processing template for graphing' do
+          output_discovery(file, @outputs, nil, nil)
+          nil
+        end
+        graph = nil
+        run_action 'Generating resource graph' do
+          graph = generate_graph(file.to_smash)
+          nil
+        end
+        run_action 'Writing graph result' do
+          FileUtils.mkdir_p(File.dirname(config[:output_file]))
+          if(config[:output_type] == 'dot')
+            File.open("#{config[:output_file]}.dot", 'w') do |file|
+              file.puts graph.to_s
+            end
+          else
+            graph.save config[:output_file], config[:output_type]
+          end
+          nil
+        end
+      end
+
+      def generate_graph(template, args={})
+        graph = ::Graph.new
+        @root_graph = graph unless @root_graph
+        graph.graph_attribs << ::Graph::Attribute.new('overlap = false')
+        graph.graph_attribs << ::Graph::Attribute.new('splines = true')
+        graph.graph_attribs << ::Graph::Attribute.new('pack = true')
+        graph.graph_attribs << ::Graph::Attribute.new('start = "random"')
+        if(args[:name])
+          graph.name = "cluster_#{args[:name]}"
+          labelnode_key = "cluster_#{args[:name]}"
+          graph.plaintext << graph.node(labelnode_key)
+          graph.node(labelnode_key).label args[:name]
+        else
+          graph.name = 'root'
+        end
+        edge_detection(template, graph, args[:name].to_s.sub('cluster_', ''), args.fetch(:resource_names, []))
+        graph
+      end
+
+      def output_discovery(template, outputs, resource_name, parent_template, name='')
+        if(template['Resources'])
+          template['Resources'].each_pair do |r_name, r_info|
+            if(r_info['Type'] == 'AWS::CloudFormation::Stack')
+              output_discovery(r_info['Properties']['Stack'], outputs, r_name, template, r_name)
+            end
+          end
+        end
+        if(parent_template)
+          substack_parameters = Smash[
+            parent_template.fetch('Resources', resource_name, 'Properties', 'Parameters', {}).map do |key, value|
+              result = [key, value]
+              if(value.is_a?(Hash))
+                v_key = value.keys.first
+                v_value = value.values.first
+                if(v_key == 'Fn::GetAtt' && parent_template.fetch('Resources', {}).keys.include?(v_value.first) && v_value.last.start_with?('Outputs.'))
+                  output_key = v_value.first << '__' << v_value.last.split('.', 2).last
+                  if(outputs.key?(output_key))
+                    new_value = outputs[output_key]
+                    result = [key, new_value]
+                  end
+                end
+              end
+              result
+            end
+          ]
+          processor = GraphProcessor.new({},
+            :parameters => substack_parameters
+          )
+          template['Resources'] = processor.dereference_processor(
+            template['Resources'], ['Ref']
+          )
+          template['Outputs'] = processor.dereference_processor(
+            template['Outputs'], ['Ref']
+          )
+          rename_processor = GraphProcessor.new({},
+            :parameters => Smash[
+              template.fetch('Resources', {}).keys.map do |r_key|
+                [r_key, {'Ref' => [name, r_key].join}]
+              end
+            ]
+          )
+          derefed_outs = rename_processor.dereference_processor(
+            template.fetch('Outputs', {})
+          ) || {}
+
+          derefed_outs.each do |o_name, o_data|
+            o_key = [name, o_name].join('__')
+            outputs[o_key] = o_data['Value']
+          end
+        end
+        outputs.dup.each do |key, value|
+          if(value.is_a?(Hash))
+            v_key = value.keys.first
+            v_value = value.values.first
+            if(v_key == 'Fn::GetAtt' && v_value.last.start_with?('Outputs.'))
+              output_key = v_value.first << '__' << v_value.last.split('.', 2).last
+              if(outputs.key?(output_key))
+                outputs[key] = outputs[output_key]
+              end
+            end
+          end
+        end
+      end
+
+      def edge_detection(template, graph, name = '', resource_names = [])
+        resources = template.fetch('Resources', {})
+        node_prefix = name
+        resources.each do |resource_name, resource_data|
+          node_name = [node_prefix, resource_name].join
+          if(resource_data['Type'] == 'AWS::CloudFormation::Stack')
+            graph.subgraph << generate_graph(
+              resource_data['Properties'].delete('Stack'),
+              :name => resource_name,
+              :type => resource_data['Type'],
+              :resource_names => resource_names
+            )
+            next
+          else
+            graph.node(node_name).attributes << graph.fillcolor(colorize(node_prefix).inspect)
+            graph.box3d << graph.node(node_name)
+          end
+          graph.filled << graph.node(node_name)
+          graph.node(node_name).label "#{resource_name}\n<#{resource_data['Type']}>\n#{name}"
+          resource_dependencies(resource_data, resource_names + resources.keys).each do |dep_name|
+            if(resources.keys.include?(dep_name))
+              dep_name = [node_prefix, dep_name].join
+            end
+            @root_graph.edge(dep_name, node_name)
+          end
+        end
+        resource_names.concat resources.keys.map{|r_name| [node_prefix, r_name].join}
+      end
+
+      def resource_dependencies(data, names)
+        case data
+        when Hash
+          data.map do |key, value|
+            if(key == 'Ref' && names.include?(value))
+              value
+            elsif(key == 'Fn::GetAtt' && names.include?(res = [value].flatten.compact.first))
+              res
+            else
+              resource_dependencies(key, names) +
+                resource_dependencies(value, names)
+            end
+          end.flatten.compact.uniq
+        when Array
+          data.map do |item|
+            resource_dependencies(item, names)
+          end.flatten.compact.uniq
+        else
+          []
+        end
+      end
+
+      def colorize(string)
+        hash = string.chars.inject(0) do |memo, chr|
+          chr.ord + ((memo << 5) - memo)
+        end
+        color = '#'
+        6.times do |count|
+          color << ('00' + ((hash >> count * 8) & 0xFF).to_s(16)).slice(-2)
+        end
+        color
+      end
+
+      class GraphProcessor < SparkleFormation::Translation
+        MAP = {}
+        REF_MAPPING = {}
+        FN_MAPPING = {}
+
+        attr_accessor :name
+
+        def initialize(template, args={})
+          super
+          @name = args[:name]
+        end
+
+        def apply_function(hash, funcs=[])
+          k, v = hash.first
+          if(hash.size == 1)
+            case k
+            when 'Ref'
+              parameters.key?(v) ? parameters[v] : hash
+            when 'Fn::Join'
+              v.last
+            when 'Fn::Select'
+              v.last[v.first.to_i]
+            else
+              hash
+            end
+          else
+            hash
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/sfn/command/inspect.rb

@@ -12,7 +12,7 @@ module Sfn
       def execute!
         name_required!
         stack_name = name_args.last
-        stack = provider.connection.stacks.get(stack_name)
+        stack = provider.stack(stack_name)
         ui.info "Stack inspection #{ui.color(stack_name, :bold)}:"
         outputs = api_action!(:api_stack => stack) do
           [:attribute, :nodes, :load_balancers, :instance_failure].map do |key|
@@ -95,7 +95,7 @@ module Sfn
       def display_attribute(stack)
         [config[:attribute]].flatten.compact.each do |stack_attribute|
           attr = stack_attribute.split('.').inject(stack) do |memo, key|
-            args = key.scan(/\(([^)]*)\)/).flatten.first.to_s
+            args = key.scan(/\(([^\)]*)\)/).flatten.first.to_s
             if(args)
               args = args.split(',').map{|a| a.to_i.to_s == a ? a.to_i : a}
               key = key.split('(').first
@@ -129,7 +129,7 @@ module Sfn
             [
               asg.name,
               Smash[
-                asg.servers.map(&:expand).map{|s|
+                asg.servers.map(&:expand).compact.map{|s|
                   [s.id, Smash.new(
                       :name => s.name,
                       :addresses => s.addresses.map(&:address)
@@ -144,11 +144,13 @@ module Sfn
             resource.within?(:compute, :servers)
           end.map do |srv|
             srv = srv.instance
-            [srv.id, Smash.new(
+            if(srv)
+              [srv.id, Smash.new(
                 :name => srv.name,
                 :addresses => srv.addresses.map(&:address)
-            )]
-          end
+              )]
+            end
+          end.compact
         ]
         unless(asg_nodes.empty?)
           ui.info '  AutoScale Group Instances:'

data/lib/sfn/command/update.rb

@@ -16,7 +16,7 @@ module Sfn
 
         stack_info = "#{ui.color('Name:', :bold)} #{name}"
         begin
-          stack = provider.connection.stacks.get(name)
+          stack = provider.stacks.get(name)
         rescue Miasma::Error::ApiError::RequestError
           stack = nil
         end
@@ -132,7 +132,6 @@ module Sfn
                 poll_stack(stack.name)
                 if(stack.reload.state == :update_complete)
                   ui.info "Stack update complete: #{ui.color('SUCCESS', :green)}"
-                  stack.resources.reload
                   namespace.const_get(:Describe).new({:outputs => true}, [name]).execute!
                 else
                   ui.fatal "Update of stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
@@ -256,18 +255,22 @@ module Sfn
             unless(val[:diffs].empty?)
               p_name = nil
               val[:diffs].each do |diff|
-                if(diff[:updated] && diff[:original])
+                if(!diff[:updated].nil? || !diff[:original].nil?)
                   p_name = diff.fetch(:property_name, :path)
                   ui.print ' ' * 8
                   ui.print "#{p_name}: "
                   ui.print ' ' * (max_p - p_name.size)
-                  ui.print ui.color("-#{diff[:original]}", :red)
-                  ui.print ' ' * (max_o - diff[:original].size)
+                  ui.print ui.color("-#{diff[:original]}", :red) unless diff[:original].nil?
+                  ui.print ' ' * (max_o - diff[:original].to_s.size)
                   ui.print ' '
                   if(diff[:updated] == Sfn::Planner::RUNTIME_MODIFIED)
                     ui.puts ui.color("+#{diff[:original]} <Dependency Modified>", :green)
                   else
-                    ui.puts ui.color("+#{diff[:updated]}", :green)
+                    if(diff[:updated].nil?)
+                      ui.puts
+                    else
+                      ui.puts ui.color("+#{diff[:updated]}", :green)
+                    end
                   end
                 end
               end
@@ -277,20 +280,6 @@ module Sfn
         end
       end
 
-      # Scrub sparkle/sfn customizations from the stack resource data
-      #
-      # @param template [Hash]
-      # @return [Hash]
-      def scrub_template(template)
-        template = Sfn::Utils::StackParameterScrubber.scrub!(template)
-        (template['Resources'] || {}).each do |r_name, r_content|
-          if(valid_stack_types.include?(r_content['Type']))
-            (r_content['Properties'] || {}).delete('Stack')
-          end
-        end
-        template
-      end
-
     end
   end
 end

data/lib/sfn/command_module/base.rb

@@ -81,7 +81,8 @@ module Sfn
         #
         # @param name [String] name of stack
         # @return [Miasma::Models::Orchestration::Stack]
-        def stack(name)
+        def stack(name=nil)
+          name = name_args.first unless name
           provider.stacks.get(name)
         end
 

data/lib/sfn/command_module/template.rb

@@ -214,16 +214,13 @@ module Sfn
         def process_nested_stack_shallow(sf, c_stack=nil)
           sf.apply_nesting(:shallow) do |stack_name, stack, resource|
             run_callbacks_for(:template, :stack_name => stack_name, :sparkle_stack => stack)
-            stack_definition = stack.compile.dump!
             bucket = provider.connection.api_for(:storage).buckets.get(
               config[:nesting_bucket]
             )
             if(config[:print_only])
               template_url = "http://example.com/bucket/#{name_args.first}_#{stack_name}.json"
             else
-              unless(config[:plan])
-                resource.properties.delete!(:stack)
-              end
+              stack_definition = dump_stack_for_storage(stack)
               unless(bucket)
                 raise "Failed to locate configured bucket for stack template storage (#{bucket})!"
               end
@@ -277,12 +274,7 @@ module Sfn
                   :current_parameters => current_parameters
                 )
               )
-              hold_stack = resource.properties.delete!(:stack)
-              stack_definition = stack.compile.dump!
-
-              if(config[:plan])
-                resource.properties.stack hold_stack
-              end
+              stack_definition = dump_stack_for_storage(stack)
               bucket = provider.connection.api_for(:storage).buckets.get(
                 config[:nesting_bucket]
               )
@@ -308,6 +300,38 @@ module Sfn
           end
         end
 
+        # Remove internally used `Stack` property from Stack resources and
+        # and generate compiled Hash
+        #
+        # @param stack [SparkleFormation]
+        # @return [Hash]
+        def dump_stack_for_storage(stack)
+          nested_stacks = stack.nested_stacks.map do |nested_resource|
+            [nested_resource.resource_name!, stack.compile.resources.set!(nested_resource.resource_name!).properties.delete!(:stack)]
+          end
+          stack_definition = stack.compile.dump!
+          if(config[:plan])
+            nested_stacks.each do |nested_name, nested_data|
+              stack.compile.resources.set!(nested_name).properties.stack nested_data
+            end
+          end
+          stack_definition
+        end
+
+        # Scrub sparkle/sfn customizations from the stack resource data
+        #
+        # @param template [Hash]
+        # @return [Hash]
+        def scrub_template(template)
+          template = Sfn::Utils::StackParameterScrubber.scrub!(template)
+          (template['Resources'] || {}).each do |r_name, r_content|
+            if(valid_stack_types.include?(r_content['Type']))
+              result = (r_content['Properties'] || {}).delete('Stack')
+            end
+          end
+          template
+        end
+
         # Update the nested stack information for specific provider
         #
         # @param provider [Symbol]

data/lib/sfn/config.rb

@@ -48,6 +48,7 @@ module Sfn
     autoload :Diff, 'sfn/config/diff'
     autoload :Events, 'sfn/config/events'
     autoload :Export, 'sfn/config/export'
+    autoload :Graph, 'sfn/config/graph'
     autoload :Import, 'sfn/config/import'
     autoload :Init, 'sfn/config/init'
     autoload :Inspect, 'sfn/config/inspect'

data/lib/sfn/config/events.rb

@@ -23,6 +23,11 @@ module Sfn
         :description => 'Display all event attributes',
         :short_flag => 'A'
       )
+      attribute(
+        :all_events,  [TrueClass, FalseClass],
+        :description => 'Display all available events',
+        :short_flag => 'L'
+      )
 
     end
   end

data/lib/sfn/config/graph.rb

@@ -0,0 +1,24 @@
+require 'sfn'
+
+module Sfn
+  class Config
+    # Generate graph
+    class Graph < Validate
+
+      attribute(
+        :output_file, String,
+        :description => 'Directory to write graph files',
+        :short_flag => 'O',
+        :default => File.join(Dir.pwd, 'sfn-graph')
+      )
+
+      attribute(
+        :output_type, String,
+        :description => 'File output type (Requires graphviz package for non-dot types)',
+        :short_flag => 'e',
+        :default => 'dot'
+      )
+
+    end
+  end
+end

data/lib/sfn/monkey_patch/stack.rb

@@ -194,7 +194,7 @@ module Sfn
       # @param recurse [TrueClass, FalseClass] recurse to fetch _all_ stacks
       # @return [Array<Miasma::Models::Orchestration::Stack>]
       def nested_stacks(recurse=true)
-        resources.all.map do |resource|
+        resources.reload.all.map do |resource|
           if(api.data.fetch(:stack_types, []).include?(resource.type))
             # Custom remote load support
             if(resource.type == 'Custom::JackalStack')

data/lib/sfn/planner/aws.rb

@@ -130,7 +130,7 @@ module Sfn
       # @return [Hash] report
       def generate_plan(template, parameters)
         parameters = Smash[parameters.map{|k,v| [k, v.to_s]}]
-        Smash.new(
+        result = Smash.new(
           :stacks => Smash.new(
             origin_stack.name => plan_stack(
               origin_stack,
@@ -145,10 +145,27 @@ module Sfn
           :unavailable => Smash.new,
           :unknown => Smash.new
         )
+#        scrub_stack_properties(template)
+        result
       end
 
       protected
 
+      # Remote custom Stack property from Stack resources within template
+      #
+      # @param template [Hash]
+      # @return [TrueClass]
+      def scrub_stack_properties(template)
+        if(template['Resources'])
+          template['Resources'].each do |name, info|
+            if(is_stack?(info['Type']) && info['Properties'].is_a?(Hash))
+              info['Properties'].delete('Stack')
+            end
+          end
+        end
+        true
+      end
+
       # Set global parameters available for all template translations.
       # These are pseudo-parameters that are provided by the
       # orchestration api runtime.
@@ -257,16 +274,17 @@ module Sfn
         o_nested_stacks = origin_template.fetch('Resources', {}).find_all do |s_name, s_val|
           is_stack?(s_val['Type'])
         end.map(&:first)
-        n_nested_stacks = new_template_hash.fetch('Resources', {}).find_all do |s_name, s_val|
+        n_nested_stacks = (new_template_hash['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?(new_template_hash['Resources'].fetch(n_name, {})['Type'])
-          n_template = new_template_hash['Resources'].fetch(n_name, {}).fetch('Properties', {})['Stack']
-          n_parameters = new_template_hash['Resources'].fetch(n_name, {}).fetch('Properties', {}).fetch('Parameters', {})
-          n_type = new_template_hash['Resources'].fetch(n_name, {})['Type'] ||
-            origin_template['Resources'][n_name]['Type']
+          n_exists = is_stack?(new_template_hash.get('Resources', n_name, 'Type'))
+          n_template = new_template_hash.get('Resources', n_name, 'Properties', 'Stack')
+          n_parameters = new_template_hash.fetch('Resources', n_name, 'Properties', 'Parameters', Smash.new)
+          n_type = new_template_hash.fetch('Resources', n_name, 'Type',
+            origin_template.get('Resources', n_name, 'Type')
+          )
           resource = Smash.new(
             :name => n_name,
             :type => n_type,
@@ -290,9 +308,7 @@ module Sfn
           end
         end
 
-        n_nested_stacks.each do |ns_name|
-          new_template_hash['Resources'][ns_name]['Properties'].delete('Stack')
-        end
+        scrub_stack_properties(new_template_hash)
 
         update_template = dereference_template(
           t_key, new_template_hash, new_parameters,
@@ -354,10 +370,14 @@ module Sfn
           else
             if(p_path.include?('Properties'))
               resource_name = p_path[1]
-              property_name = p_path[3].sub(/\[\d+\]$/, '')
+              if(p_path.size < 4 && p_path.last == 'Properties')
+                property_name = diff.flatten.compact.last.keys.first
+              else
+                property_name = p_path[3].to_s.sub(/\[\d+\]$/, '')
+              end
               type = templates[:origin]['Resources'][resource_name]['Type']
-              info = SfnAws.registry.fetch(type, {})
-              effect = info[:full_properties].fetch(property_name, {}).fetch(:update_causes, :unknown).to_sym
+              info = SfnAws.registry.fetch(type, {}).to_smash
+              effect = info.fetch(:full_properties, property_name, :update_causes, :unknown).to_sym
               resource = Smash.new(
                 :name => resource_name,
                 :type => type,

data/lib/sfn/provider.rb

@@ -88,20 +88,26 @@ module Sfn
     end
 
     # @return [Miasma::Orchestration::Stacks]
-    def stacks
-      connection.stacks.from_json(cached_stacks)
+    def stacks(stack_id=nil)
+      connection.stacks.from_json(cached_stacks(stack_id))
     end
 
     # @return [String] json representation of cached stacks
-    def cached_stacks
-      fetch_stacks unless @initial_fetch_complete
+    def cached_stacks(stack_id=nil)
+      unless(@initial_fetch_complete || stack_id)
+        recache = true
+        if(stack_id && @initial_fetch_complete)
+          recache = !!stacks.get(stack_id)
+        end
+        fetch_stacks(stack_id) if recache
+      end
       value = cache[:stacks].value
       value ? MultiJson.dump(MultiJson.load(value).values) : '[]'
     end
 
     # @return [Miasma::Orchestration::Stack, NilClass]
     def stack(stack_id)
-      stacks.get(stack_id)
+      stacks(stack_id).get(stack_id)
     end
 
     # Store stack attribute changes
@@ -162,23 +168,32 @@ module Sfn
     # Request stack information and store in cache
     #
     # @return [TrueClass]
-    def fetch_stacks
+    def fetch_stacks(stack_id=nil)
       cache.locked_action(:stacks_lock) do
         logger.info "Lock aquired for stack update. Requesting stacks from upstream. (#{Thread.current})"
-        stacks = Hash[
-          connection.stacks.reload.all.map do |stack|
-            [stack.id, stack.attributes]
-          end
-        ]
+        if(stack_id)
+          single_stack = connection.stacks.get(stack_id)
+          stacks = single_stack ? {single_stack.id => single_stack} : {}
+        else
+          stacks = Hash[
+            connection.stacks.reload.all.map do |stack|
+              [stack.id, stack.attributes]
+            end
+          ]
+        end
         if(cache[:stacks].value)
           existing_stacks = MultiJson.load(cache[:stacks].value)
           # Force common types
           stacks = MultiJson.load(MultiJson.dump(stacks))
-          # Remove stacks that have been deleted
-          stale_ids = existing_stacks.keys - stacks.keys
-          stacks = existing_stacks.to_smash.deep_merge(stacks)
-          stale_ids.each do |stale_id|
-            stacks.delete(stale_id)
+          if(stack_id)
+            stacks = existing_stacks.to_smash.deep_merge(stacks)
+          else
+            # Remove stacks that have been deleted
+            stale_ids = existing_stacks.keys - stacks.keys
+            stacks = existing_stacks.to_smash.deep_merge(stacks)
+            stale_ids.each do |stale_id|
+              stacks.delete(stale_id)
+            end
           end
         end
         cache[:stacks].value = stacks.to_json

data/lib/sfn/version.rb

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

data/sfn.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |s|
   s.license = 'Apache-2.0'
   s.require_path = 'lib'
   s.add_runtime_dependency 'bogo-cli', '>= 0.2.4', '< 0.4'
+  s.add_runtime_dependency 'bogo-ui', '>= 0.1.13', '< 0.4'
   s.add_runtime_dependency 'miasma', '>= 0.3.0', '< 0.4'
   s.add_runtime_dependency 'miasma-aws', '>= 0.3.0', '< 0.4'
   s.add_runtime_dependency 'miasma-azure', '>= 0.1.0', '< 0.3'
@@ -19,7 +20,8 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'net-ssh'
   s.add_runtime_dependency 'sparkle_formation', '>= 2.1.2', '< 3'
   s.add_runtime_dependency 'hashdiff', '~> 0.2.2'
-  s.add_development_dependency 'rake'
+  s.add_runtime_dependency 'graph', '~> 2.8.1'
+  s.add_development_dependency 'rake', '~> 10'
   s.add_development_dependency 'minitest'
   s.add_development_dependency 'mocha'
   s.executables << 'sfn'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sfn
 version: !ruby/object:Gem::Version
-  version: 2.1.6
+  version: 2.1.8
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-02 00:00:00.000000000 Z
+date: 2016-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bogo-cli
@@ -30,6 +30,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: bogo-ui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.13
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.13
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: miasma
   requirement: !ruby/object:Gem::Requirement
@@ -178,20 +198,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.2
+- !ruby/object:Gem::Dependency
+  name: graph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -271,6 +305,7 @@ files:
 - lib/sfn/command/diff.rb
 - lib/sfn/command/events.rb
 - lib/sfn/command/export.rb
+- lib/sfn/command/graph.rb
 - lib/sfn/command/import.rb
 - lib/sfn/command/init.rb
 - lib/sfn/command/inspect.rb
@@ -292,6 +327,7 @@ files:
 - lib/sfn/config/diff.rb
 - lib/sfn/config/events.rb
 - lib/sfn/config/export.rb
+- lib/sfn/config/graph.rb
 - lib/sfn/config/import.rb
 - lib/sfn/config/init.rb
 - lib/sfn/config/inspect.rb