sfn 0.5.0 → 1.0.0

data/lib/sfn/command/update.rb

@@ -18,100 +18,77 @@ module Sfn
         end
 
         stack_info = "#{ui.color('Name:', :bold)} #{name}"
-        stack = provider.connection.stacks.get(name)
-
-        config[:compile_parameters] ||= Smash.new
+        begin
+          stack = provider.connection.stacks.get(name)
+        rescue Miasma::Error::ApiError::RequestError
+          stack = nil
+        end
 
         if(config[:file])
-          s_name = [name]
-          c_setter = lambda do |c_stack|
-            compile_params = c_stack.outputs.detect do |output|
-              output.key == 'CompileState'
-            end
-            if(compile_params)
-              compile_params = MultiJson.load(compile_params.value)
-              c_current = config[:compile_parameters].fetch(s_name.join('_'), Smash.new)
-              config[:compile_parameters][s_name.join('_')] = compile_params.merge(c_current)
-            end
-          end
-
-          if(stack)
-            c_setter.call(stack)
-            stack.resources.all.each do |s_resource|
-              if(s_resource.type == 'AWS::CloudFormation::Stack')
-                s_name.push(s_resource.logical_id)
-                c_setter.call(s_resource.expand)
-                s_name.pop
-              end
-            end
-          end
-
-          file = load_template_file
+          file = load_template_file(:stack => stack)
           stack_info << " #{ui.color('Path:', :bold)} #{config[:file]}"
           nested_stacks = file.delete('sfn_nested_stack')
         end
 
         if(nested_stacks)
-
           unpack_nesting(name, file, :update)
-
         else
-          stack = provider.connection.stacks.get(name)
+          unless(stack)
+            ui.fatal "Failed to locate requested stack: #{ui.color(name, :red, :bold)}"
+            raise "Failed to locate stack: #{name}"
+          end
 
-          if(stack)
-            ui.info "#{ui.color('SparkleFormation:', :bold)} #{ui.color('update', :green)}"
+          ui.info "#{ui.color('Cloud Formation:', :bold)} #{ui.color('update', :green)}"
 
-            unless(file)
-              if(config[:template])
-                file = config[:template]
-                stack_info << " #{ui.color('(template provided)', :green)}"
-              else
-                stack_info << " #{ui.color('(no template update)', :yellow)}"
-              end
+          unless(file)
+            if(config[:template])
+              file = config[:template]
+              stack_info << " #{ui.color('(template provided)', :green)}"
+            else
+              stack_info << " #{ui.color('(no template update)', :yellow)}"
             end
-            ui.info "  -> #{stack_info}"
+          end
+          ui.info "  -> #{stack_info}"
 
+          apply_stacks!(stack)
 
-            if(file)
-              stack.template = translate_template(file)
-              apply_stacks!(stack)
-              populate_parameters!(file, stack.parameters)
-              stack.parameters = config[:parameters]
-              stack.template = Sfn::Utils::StackParameterScrubber.scrub!(stack.template)
-            else
-              apply_stacks!(stack)
-              populate_parameters!(stack.template, stack.parameters)
-              stack.parameters = config[:parameters]
+          if(file)
+            if(config[:print_only])
+              ui.puts _format_json(translate_template(file))
+              return
             end
+            populate_parameters!(file, :current_parameters => stack.parameters)
+            stack.template = translate_template(file)
+            stack.parameters = config_root_parameters
+            stack.template = Sfn::Utils::StackParameterScrubber.scrub!(stack.template)
+          else
+            populate_parameters!(stack.template, :current_parameters => stack.parameters)
+            stack.parameters = config_root_parameters
+          end
 
-            begin
+          begin
+            api_action!(:api_stack => stack) do
               stack.save
-            rescue Miasma::Error::ApiError::RequestError => e
-              if(e.message.downcase.include?('no updates'))
-                ui.warn "No updates detected for stack (#{stack.name})"
+              if(config[:poll])
+                poll_stack(stack.name)
+                if(stack.reload.state == :update_complete)
+                  ui.info "Stack update complete: #{ui.color('SUCCESS', :green)}"
+                  namespace.const_get(:Describe).new({:outputs => true}, [name]).execute!
+                else
+                  ui.fatal "Update of stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
+                  raise
+                end
               else
-                raise
+                ui.warn 'Stack state polling has been disabled.'
+                ui.info "Stack update initialized for #{ui.color(name, :green)}"
               end
             end
-
-            if(config[:poll])
-              poll_stack(stack.name)
-              if(stack.reload.state == :update_complete)
-                ui.info "Stack update complete: #{ui.color('SUCCESS', :green)}"
-                namespace.const_get(:Describe).new({:outputs => true}, [name]).execute!
-              else
-                ui.fatal "Update of stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
-                ui.info ""
-                namespace.const_get(:Inspect).new({:instance_failure => true}, [name]).execute!
-                raise
-              end
+          rescue Miasma::Error::ApiError::RequestError => e
+            if(e.message.downcase.include?('no updates'))
+              ui.warn "No updates detected for stack (#{stack.name})"
             else
-              ui.warn 'Stack state polling has been disabled.'
-              ui.info "Stack update initialized for #{ui.color(name, :green)}"
+              raise
             end
-          else
-            ui.fatal "Failed to locate requested stack: #{ui.color(name, :red, :bold)}"
-            raise
           end
 
         end

data/lib/sfn/command/validate.rb

@@ -8,23 +8,49 @@ module Sfn
 
       include Sfn::CommandModule::Base
       include Sfn::CommandModule::Template
+      include Sfn::CommandModule::Stack
 
       def execute!
+        print_only_original = config[:print_only]
+        config[:print_only] = true
         file = load_template_file
         file.delete('sfn_nested_stack')
         ui.info "#{ui.color("Template Validation (#{provider.connection.provider}): ", :bold)} #{config[:file].sub(Dir.pwd, '').sub(%r{^/}, '')}"
         file = Sfn::Utils::StackParameterScrubber.scrub!(file)
         file = translate_template(file)
+        config[:print_only] = print_only_original
+
+        if(config[:print_only])
+          ui.puts _format_json(file)
+        else
+          validate_stack(file, sparkle_collection.get(:template, config[:file])[:name])
+        end
+      end
+
+      def validate_stack(stack, name)
+        resources = stack.fetch('Resources', {})
+        nested_stacks = resources.find_all do |r_name, r_value|
+          r_value.is_a?(Hash) &&
+            provider.connection.class.const_get(:RESOURCE_MAPPING).fetch(r_value['Type'], {})[:api] == :orchestration
+        end
+        nested_stacks.each do |n_name, n_resource|
+          validate_stack(n_resource.fetch('Properties', {}).fetch('Stack', {}), "#{name} > #{n_name}")
+          n_resource['Properties'].delete('Stack')
+        end
         begin
-          result = provider.connection.stacks.build(
+          ui.info "Validating: #{ui.color(name, :bold)}"
+          stack = provider.connection.stacks.build(
             :name => 'validation-stack',
-            :template => file
-          ).validate
+            :template => Sfn::Utils::StackParameterScrubber.scrub!(stack)
+          )
+          result = api_action!(:api_stack => stack) do
+            stack.validate
+          end
           ui.info ui.color('  -> VALID', :bold, :green)
         rescue => e
           ui.info ui.color('  -> INVALID', :bold, :red)
           ui.fatal e.message
-          failed = true
+          raise e
         end
       end
 

data/lib/sfn/command.rb

@@ -18,8 +18,7 @@ module Sfn
 
     # Override to provide config file searching
     def initialize(cli_opts, args)
-      unless(cli_opts[:config])
-        cli_opts = cli_opts.to_hash.to_smash(:snake)
+      unless(cli_opts['config'])
         discover_config(cli_opts)
       end
       super(cli_opts, args)
@@ -37,14 +36,18 @@ module Sfn
     # Start with current working directory and traverse to root
     # looking for a `.sfn` configuration file
     #
-    # @param opts [Smash]
-    # @return [Smash]
+    # @param opts [Slop]
+    # @return [Slop]
     def discover_config(opts)
       cwd = Dir.pwd.split(File::SEPARATOR)
       until(cwd.empty? || File.exists?(cwd.push('.sfn').join(File::SEPARATOR)))
         cwd.pop(2)
       end
-      opts[:config] = cwd.join(File::SEPARATOR) unless cwd.empty?
+      if(opts.respond_to?(:fetch_option))
+        opts.fetch_option('config').value = cwd.join(File::SEPARATOR) unless cwd.empty?
+      else
+        opts['config'] = cwd.join(File::SEPARATOR) unless cwd.empty?
+      end
       opts
     end
 

data/lib/sfn/command_module/base.rb

@@ -11,11 +11,16 @@ module Sfn
         # @return [KnifeCloudformation::Provider]
         def provider
           memoize(:provider, :direct) do
-            Sfn::Provider.new(
+            result = Sfn::Provider.new(
               :miasma => config[:credentials],
               :async => false,
               :fetch => false
             )
+            result.connection.data[:retry_ui] = ui
+            result.connection.data[:retry_type] = config.fetch(:retry, :type, :exponential)
+            result.connection.data[:retry_interval] = config.fetch(:retry, :interval, 5)
+            result.connection.data[:retry_max] = config.fetch(:retry, :max_attempts, 20)
+            result
           end
         end
 
@@ -117,9 +122,18 @@ module Sfn
           arguments
         end
 
+        # Override config method to memoize the result allowing for
+        # modifications to the configuration during runtime
+        #
+        # @return [Smash]
+        # @note callback requires are also loaded here
         def config
           memoize(:config) do
-            super
+            result = super
+            result.fetch(:callbacks, :require, []).each do |c_loader|
+              require c_loader
+            end
+            result
           end
         end
 
@@ -130,6 +144,7 @@ module Sfn
           klass.instance_eval do
 
             include Sfn::CommandModule::Base::InstanceMethods
+            include Sfn::CommandModule::Callbacks
             include Sfn::Utils::JSON
             include Sfn::Utils::Output
             include Bogo::AnimalStrings

data/lib/sfn/command_module/callbacks.rb

@@ -0,0 +1,69 @@
+require 'sfn'
+require 'sparkle_formation'
+
+module Sfn
+  module CommandModule
+    # Callback processor helpers
+    module Callbacks
+
+      include Bogo::Memoization
+
+      # Run expected callbacks around action
+      #
+      # @yieldblock api action to run
+      # @yieldresult [Object] result from call
+      # @return [Object] result of yield block
+      def api_action!(*args)
+        type = self.class.name.split('::').last.downcase
+        run_callbacks_for(["before_#{type}", :before], *args)
+        result = yield if block_given?
+        run_callbacks_for(["after_#{type}", :after], *args)
+        result
+      end
+
+      # Process requested callbacks
+      #
+      # @param type [Symbol, String] name of callback type
+      # @return [NilClass]
+      def run_callbacks_for(type, *args)
+        types = [type].flatten.compact
+        type = types.first
+        clbks = types.map do |c_type|
+          callbacks_for(c_type)
+        end.flatten(1).compact.uniq.each do |item|
+          callback_name, callback = item
+          ui.info "Callback #{ui.color(type.to_s, :bold)} #{callback_name}: #{ui.color('starting', :yellow)}"
+          if(args.empty?)
+            callback.call
+          else
+            callback.call(*args)
+          end
+          ui.info "Callback #{ui.color(type.to_s, :bold)} #{callback_name}: #{ui.color('complete', :green)}"
+        end
+        nil
+      end
+
+      # Fetch valid callbacks for given type
+      #
+      # @param type [Symbol, String] name of callback type
+      # @param responder [Array<String, Symbol>] matching response methods
+      # @return [Array<Method>]
+      def callbacks_for(type)
+        ([config.fetch(:callbacks, type, [])].flatten.compact + [config.fetch(:callbacks, :default, [])].flatten.compact).map do |c_name|
+          instance = memoize(c_name) do
+            begin
+              klass = Sfn::Callback.const_get(Bogo::Utility.camel(c_name.to_s))
+              klass.new(ui, config, arguments, provider)
+            rescue NameError
+              raise "Unknown #{type} callback requested: #{c_name} (not found)"
+            end
+          end
+          if(instance.respond_to?(type))
+            [c_name, instance.method(type)]
+          end
+        end.compact
+      end
+
+    end
+  end
+end

data/lib/sfn/command_module/stack.rb

@@ -104,10 +104,25 @@ module Sfn
 
         # Prompt for parameter values and store result
         #
-        # @param stack [Hash] stack template
+        # @param sparkle [SparkleFormation, Hash]
+        # @param opts [Hash]
+        # @option opts [Hash] :current_parameters current stack parameter values
+        # @option opts [Miasma::Models::Orchestration::Stack] :stack existing stack
         # @return [Hash]
-        def populate_parameters!(stack, current_params={})
-          if(stack['Parameters'])
+        def populate_parameters!(sparkle, opts={})
+          current_parameters = opts.fetch(:current_parameters, {})
+          current_stack = opts[:stack]
+          if(sparkle.is_a?(SparkleFormation))
+            parameter_prefix = sparkle.root? ? [] : (sparkle.root_path - [sparkle.root]).map do |s|
+              Bogo::Utility.camel(s.name)
+            end
+            stack_parameters = sparkle.compile.parameters
+            stack_parameters = stack_parameters.nil? ? Smash.new : stack_parameters._dump
+          else
+            parameter_prefix = []
+            stack_parameters = sparkle.fetch('Parameters', Smash.new)
+          end
+          unless(stack_parameters.empty?)
             if(config.get(:parameter).is_a?(Array))
               config[:parameter] = Smash[
                 *config.get(:parameter).map(&:to_a).flatten
@@ -120,14 +135,37 @@ module Sfn
             else
               config.set(:parameters, config.fetch(:parameter, Smash.new))
             end
-            stack.fetch('Parameters', {}).each do |k,v|
-              next if config[:parameters][k]
-              attempt = 0
+            stack_parameters.each do |k,v|
+              ns_k = (parameter_prefix + [k]).compact.join('__')
+              next if config[:parameters][ns_k]
               valid = false
+              # When parameter is a hash type, it is being set via
+              # intrinsic function and we don't modify
+              if(current_parameters[k].is_a?(Hash))
+                if(current_stack)
+                  enable_set = validate_stack_parameter(current_stack, k, ns_k, current_parameters[k])
+                else
+                  enable_set = true
+                end
+                if(enable_set)
+                  # NOTE: direct set dumps the stack (nfi). Smash will
+                  # auto dup it, and works, so yay i guess.
+                  config[:parameters][ns_k] = Smash.new(current_parameters[k])
+                  valid = true
+                end
+              else
+                if(current_stack && current_stack.data[:parent_stack])
+                  use_expected = validate_stack_parameter(current_stack, k, ns_k, current_parameters[k])
+                  unless(use_expected)
+                    current_parameters[k] = current_stack.parameters[k]
+                  end
+                end
+              end
+              attempt = 0
               until(valid)
                 attempt += 1
                 default = config[:parameters].fetch(
-                  k, current_params.fetch(
+                  ns_k, current_parameters.fetch(
                     k, v['Default']
                   )
                 )
@@ -138,7 +176,7 @@ module Sfn
                 end
                 validation = Sfn::Utils::StackParameterValidator.validate(answer, v)
                 if(validation == true)
-                  config[:parameters][k] = answer
+                  config[:parameters][ns_k] = answer
                   valid = true
                 else
                   validation.each do |validation_error|
@@ -152,7 +190,67 @@ module Sfn
               end
             end
           end
-          stack
+          Smash[
+            config.fetch(:parameters, {}).map do |k,v|
+              strip_key = parameter_prefix ? k.sub(/#{parameter_prefix.join('__')}_{2}?/, '') : k
+              unless(strip_key.include?('__'))
+                [strip_key, v]
+              end
+            end.compact
+          ]
+        end
+
+        # @return [Hash] parameters for root stack create/update
+        def config_root_parameters
+          Hash[
+            config.fetch(:parameters, {}).find_all do |k,v|
+              !k.include?('__')
+            end
+          ]
+        end
+
+        # Validate stack parameter is properly set via stack resource
+        # from parent stack. If not properly set, prompt user for
+        # expected behavior. This accounts for states encountered when
+        # a nested stack's parameters are adjusted directly but the
+        # resource sets value via intrinsic function.
+        #
+        # @param c_stack [Miasma::Models::Orchestration::Stack] current stack
+        # @param p_key [String] stack parameter key
+        # @param p_ns_key [String] namespaced stack parameter key
+        # @param c_value [Hash] currently set value (via intrinsic function)
+        # @return [TrueClass, FalseClass] value is validated
+        def validate_stack_parameter(c_stack, p_key, p_ns_key, c_value)
+          stack_value = c_stack.parameters[p_key]
+          p_stack = c_stack.data[:parent_stack]
+          if(c_value.is_a?(Hash))
+            case c_value.keys.first
+            when 'Ref'
+              current_value = p_stack.parameters[c_value.values.first]
+            when 'Fn::Att'
+              resource_name, output_name = c_value.values.first.split('.', 2)
+              ref_stack = p_stack.nested_stacks.detect{|i| i.data[:logical_id] == resource_name}
+              if(ref_stack)
+                output = ref_stack.outputs.detect do |o|
+                  o.key == output_name
+                end
+                if(output)
+                  current_value = output.value
+                end
+              end
+            end
+          else
+            current_value = c_value
+          end
+          if(current_value && current_value != stack_value)
+            ui.warn 'Nested stack has been altered directly! This update may cause unexpected modifications!'
+            ui.warn "Stack name: #{c_stack.name}. Parameter: #{p_key}. Current value: #{stack_value}. Expected value: #{current_value} (via: #{c_value.inspect})"
+            answer = ui.ask_question("Use current value or expected value for #{p_key} [current/expected]?", :valid => ['current', 'expected'])
+            answer == 'expected'
+          else
+            ui.warn "Unable to check #{p_key} for direct value modification. (Cannot auto-check expected value #{c_value.inspect})"
+            true
+          end
         end
 
       end