sfn 2.2.0 → 3.0.0

data/lib/sfn/command/update.rb

@@ -27,16 +27,18 @@ module Sfn
           s_name = [name]
 
           c_setter = lambda do |c_stack|
-            compile_params = c_stack.outputs.detect do |output|
-              output.key == 'CompileState'
+            if(c_stack.outputs)
+              compile_params = c_stack.outputs.detect do |output|
+                output.key == 'CompileState'
+              end
             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)
+              c_current = config[:compile_parameters].fetch(s_name.join('__'), Smash.new)
+              config[:compile_parameters][s_name.join('__')] = compile_params.merge(c_current)
             end
             c_stack.nested_stacks(false).each do |n_stack|
-              s_name.push(n_stack.name)
+              s_name.push(n_stack.data.fetch(:logical_id, n_stack.name))
               c_setter.call(n_stack)
               s_name.pop
             end
@@ -46,114 +48,114 @@ module Sfn
             c_setter.call(stack)
           end
 
+          ui.debug "Compile parameters - #{config[:compile_parameters]}"
           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
-          unless(stack)
-            ui.fatal "Failed to locate requested stack: #{ui.color(name, :red, :bold)}"
-            raise "Failed to locate stack: #{name}"
-          end
+        unless(stack)
+          ui.fatal "Failed to locate requested stack: #{ui.color(name, :red, :bold)}"
+          raise "Failed to locate stack: #{name}"
+        end
 
-          ui.info "#{ui.color('SparkleFormation:', :bold)} #{ui.color('update', :green)}"
+        ui.info "#{ui.color('SparkleFormation:', :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}"
 
-          if(file)
-            if(config[:print_only])
-              ui.puts _format_json(translate_template(file))
-              return
-            end
+        if(file)
+          if(config[:print_only])
+            ui.puts format_json(parameter_scrub!(template_content(file)))
+            return
+          end
 
-            original_template = stack.template
-            original_parameters = stack.parameters
+          original_template = stack.template
+          original_parameters = stack.parameters
 
-            stack.template = translate_template(file)
-            apply_stacks!(stack)
+          apply_stacks!(stack)
 
-            populate_parameters!(file, :current_parameters => stack.parameters)
-            update_template = stack.template
+          populate_parameters!(file, :current_parameters => stack.root_parameters)
+          update_template = stack.template
 
-            if(config[:plan])
-              begin
-                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
-              rescue => e
-                unless(e.message.include?('Confirmation declined'))
-                  ui.error "Unexpected error when generating plan information: #{e.class} - #{e}"
-                  ui.debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-                  ui.confirm 'Continue with stack update?' unless config[:plan_only]
-                else
-                  raise
-                end
+          if(config[:plan])
+            begin
+              stack.template = original_template
+              stack.parameters = original_parameters
+              plan = build_planner(stack)
+              if(plan)
+                result = plan.generate_plan(file.dump, config_root_parameters)
+                display_plan_information(result)
               end
-              if(config[:plan_only])
-                ui.info 'Plan only mode requested. Exiting.'
-                exit 0
+            rescue => e
+              unless(e.message.include?('Confirmation declined'))
+                ui.error "Unexpected error when generating plan information: #{e.class} - #{e}"
+                ui.debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+                ui.confirm 'Continue with stack update?' unless config[:plan_only]
+              else
+                raise
               end
             end
-
-            stack.parameters = config_root_parameters
-            stack.template = scrub_template(update_template)
-          else
-            apply_stacks!(stack)
-            original_parameters = stack.parameters
-            populate_parameters!(stack.template, :current_parameters => stack.parameters)
-            stack.parameters = config_root_parameters
+            if(config[:plan_only])
+              ui.info 'Plan only mode requested. Exiting.'
+              exit 0
+            end
           end
+          stack.parameters = config_root_parameters
+        else
+          apply_stacks!(stack)
+          original_parameters = stack.parameters
+          populate_parameters!(file, :current_parameters => stack.root_parameters)
+          stack.parameters = config_root_parameters
+        end
 
-          # Set options defined within config into stack instance for update request
-          if(config[:merge_api_options])
-            config.fetch(:options, Smash.new).each_pair do |key, value|
-              if(stack.respond_to?("#{key}="))
-                stack.send("#{key}=", value)
-              end
+        if(config[:upload_root_template])
+          upload_result = store_template(name, file, Smash.new)
+          stack.template_url = upload_result[:url]
+        else
+          stack.template = parameter_scrub!(template_content(file, :scrub))
+        end
+
+        # Set options defined within config into stack instance for update request
+        if(config[:merge_api_options])
+          config.fetch(:options, Smash.new).each_pair do |key, value|
+            if(stack.respond_to?("#{key}="))
+              stack.send("#{key}=", value)
             end
           end
+        end
 
-          begin
-            api_action!(:api_stack => stack) do
-              stack.save
-              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 'Stack did not reach a successful update completion state.'
-                end
+        begin
+          api_action!(:api_stack => stack) do
+            stack.save
+            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.warn 'Stack state polling has been disabled.'
-                ui.info "Stack update initialized for #{ui.color(name, :green)}"
+                ui.fatal "Update of stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
+                raise 'Stack did not reach a successful update completion state.'
               end
-            end
-          rescue Miasma::Error::ApiError::RequestError => e
-            if(e.message.downcase.include?('no updates'))
-              ui.warn "No updates detected for stack (#{stack.name})"
             else
-              raise
+              ui.warn 'Stack state polling has been disabled.'
+              ui.info "Stack update initialized for #{ui.color(name, :green)}"
             end
           end
-
+        rescue Miasma::Error::ApiError::RequestError => e
+          if(e.message.downcase.include?('no updates'))
+            ui.warn "No updates detected for stack (#{stack.name})"
+          else
+            raise
+          end
         end
+
       end
 
       def build_planner(stack)

data/lib/sfn/command/validate.rb

@@ -14,21 +14,25 @@ module Sfn
         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
 
+        raw_template = _format_json(parameter_scrub!(template_content(file)))
+
         if(config[:print_only])
-          ui.puts _format_json(file)
+          ui.puts raw_template
         else
-          validate_stack(file, sparkle_collection.get(:template, config[:file])[:name])
+          validate_stack(file.dump, sparkle_collection.get(:template, config[:file])[:name])
         end
       end
 
-      def validate_stack(stack, name)
-        resources = stack.fetch('Resources', {})
+      # Validate template with remote API and unpack nested templates if required
+      #
+      # @param template [Hash] template data structure
+      # @param name [String] name of template
+      # @return [TrueClass]
+      def validate_stack(template, name)
+        resources = template.fetch('Resources', {})
         nested_stacks = resources.find_all do |r_name, r_value|
           r_value.is_a?(Hash) &&
             provider.connection.data[:stack_types].include?(r_value['Type'])
@@ -39,14 +43,23 @@ module Sfn
         end
         begin
           ui.info "Validating: #{ui.color(name, :bold)}"
-          stack = provider.connection.stacks.build(
-            :name => 'validation-stack',
-            :template => Sfn::Utils::StackParameterScrubber.scrub!(stack)
-          )
+          if(config[:upload_root_template])
+            upload_result = store_template('validation-stack', template, Smash.new)
+            stack = provider.connection.stacks.build(
+              :name => 'validation-stack',
+              :template_url => upload_result[:url]
+            )
+          else
+            stack = provider.connection.stacks.build(
+              :name => 'validation-stack',
+              :template => parameter_scrub!(template)
+            )
+          end
           result = api_action!(:api_stack => stack) do
             stack.validate
           end
           ui.info ui.color('  -> VALID', :bold, :green)
+          true
         rescue => e
           ui.info ui.color('  -> INVALID', :bold, :red)
           ui.fatal e.message

data/lib/sfn/command_module/base.rb

@@ -110,18 +110,7 @@ module Sfn
         def poll_stack(name)
           provider.connection.stacks.reload
           retry_attempts = 0
-          begin
-            events = Sfn::Command::Events.new({:poll => true}, [name]).execute!
-          rescue => e
-            if(retry_attempts < config.fetch(:max_poll_retries, 5).to_i)
-              retry_attempts += 1
-              warn "Unexpected error encountered (#{e.class}: #{e}) Retrying [retry count: #{retry_attempts}]"
-              sleep(1)
-              retry
-            else
-              raise
-            end
-          end
+          events = Sfn::Command::Events.new({:poll => true}, [name]).execute!
         end
 
         # Wrapper for information retrieval. Provides consistent error

data/lib/sfn/command_module/stack.rb

@@ -8,8 +8,6 @@ module Sfn
 
       module InstanceMethods
 
-        # unpacked stack name joiner/identifier
-        UNPACK_NAME_JOINER = '-sfn-'
         # maximum number of attempts to get valid parameter value
         MAX_PARAMETER_ATTEMPTS = 5
         # Template parameter locations
@@ -24,12 +22,14 @@ module Sfn
         def apply_stacks!(stack)
           remote_stacks = [config[:apply_stack]].flatten.compact
           remote_stacks.each do |stack_name|
-            remote_stack = provider.connection.stacks.get(stack_name)
+            remote_stack = provider.stack(stack_name)
             if(remote_stack)
               apply_nested_stacks!(remote_stack, stack)
-              stack.apply_stack(remote_stack)
+              mappings = generate_custom_apply_mappings(remote_stack)
+              execute_apply_stack(remote_stack, stack, mappings)
             else
-              apply_unpacked_stack!(stack_name, stack)
+              ui.error "Failed to apply requested stack. Unable to locate. (#{stack_name})"
+              raise "Failed to locate stack: #{stack}"
             end
           end
           stack
@@ -42,67 +42,47 @@ module Sfn
         # @return [Miasma::Models::Orchestration::Stack]
         def apply_nested_stacks!(remote_stack, stack)
           remote_stack.resources.all.each do |resource|
-            if(resource.type == 'AWS::CloudFormation::Stack')
+            if(valid_stack_types.include?(resource.type))
               nested_stack = resource.expand
               apply_nested_stacks!(nested_stack, stack)
-              stack.apply_stack(nested_stack)
+              mappings = generate_custom_apply_mappings(nested_stack)
+              execute_apply_stack(nested_stack, stack, mappings)
             end
           end
           stack
         end
 
-        # Apply all stacks from an unpacked stack
+        # Build apply mappings valid for given provider stack
         #
-        # @param stack_name [String] name of parent stack
-        # @param stack [Miasma::Models::Orchestration::Stack]
-        # @return [Miasma::Models::Orchestration::Stack]
-        def apply_unpacked_stack!(stack_name, stack)
-          result = provider.connection.stacks.all.find_all do |remote_stack|
-            remote_stack.name.start_with?("#{stack_name}#{UNPACK_NAME_JOINER}")
-          end.sort_by(&:name).map do |remote_stack|
-            stack.apply_stack(remote_stack)
-          end
-          unless(result.empty?)
-            stack
-          else
-            ui.error "Failed to apply requested stack. Unable to locate. (#{stack_name})"
-            raise "Failed to locate stack: #{stack_name}"
+        # @param provider_stack [Miasma::Models::Orchestration::Stack] stack providing outputs
+        # @return [Hash] output to parameter mapping
+        def generate_custom_apply_mappings(provider_stack)
+          if(config[:apply_mapping])
+            valid_keys = config[:apply_mapping].keys.find_all do |a_key|
+              a_key = a_key.to_s
+              !a_key.include?('__') ||
+                a_key.split('__').first == provider_stack.name
+            end
+            to_remove = valid_keys.find_all do |key|
+              valid_keys.any?{|v_key| v_key.match(/__#{Regexp.escape(key)}$/)}
+            end
+            valid_keys -= to_remove
+            Hash[
+              valid_keys.map do |a_key|
+                cut_key = a_key.include?('__') ? a_key.slice(a_key.index('__') + 2, a_key.length) : a_key
+                [cut_key, config[:apply_mapping][a_key]]
+              end
+            ]
           end
         end
 
-        # Unpack nested stack and run action on each stack, applying
-        # the previous stacks automatically
+        # Apply provider stack outputs to receiver stack parameters
         #
-        # @param name [String] container stack name
-        # @param file [Hash] stack template
-        # @param action [String] create or update
+        # @param provider_stack [Miasma::Models::Orchestration::Stack] stack providing outputs
+        # @param receiver_stack [Miasma::Models::Orchestration::Stack] stack receiving outputs for parameters
         # @return [TrueClass]
-        def unpack_nesting(name, file, action)
-          config[:apply_stacks] ||= []
-          stack_count = 0
-          file['Resources'].each do |stack_resource_name, stack_resource|
-
-            nested_stack_name = "#{name}#{UNPACK_NAME_JOINER}#{Kernel.sprintf('%0.3d', stack_count)}-#{stack_resource_name}"
-            nested_stack_template = stack_resource['Properties']['Stack']
-
-            namespace.const_get(action.to_s.capitalize).new(
-              Smash.new(
-                :print_only => config[:print_only],
-                :template => nested_stack_template,
-                :parameters => config.fetch(:parameters, Smash.new).to_smash,
-                :apply_stacks => config[:apply_stacks],
-                :options => config[:options]
-              ),
-              [nested_stack_name]
-            ).execute!
-            unless(config[:print_only])
-              config[:apply_stacks].push(nested_stack_name).uniq!
-            end
-            config[:template] = nil
-            provider.connection.stacks.reload
-            stack_count += 1
-          end
-
+        def execute_apply_stack(provider_stack, receiver_stack, mappings)
+          receiver_stack.apply_stack(provider_stack, :mapping => mappings)
           true
         end
 
@@ -148,7 +128,7 @@ module Sfn
               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(function_set_parameter?(current_parameters[k]))
                 if(current_stack)
                   enable_set = validate_stack_parameter(current_stack, k, ns_k, current_parameters[k])
                 else
@@ -157,7 +137,7 @@ module Sfn
                 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])
+                  config[:parameters][ns_k] = current_parameters[k].is_a?(Hash) ? Smash.new(current_parameters[k]) : current_parameters[k].dup
                   valid = true
                 end
               else
@@ -189,7 +169,7 @@ module Sfn
                 else
                   answer = default
                 end
-                validation = Sfn::Utils::StackParameterValidator.validate(answer, v)
+                validation = validate_parameter(answer, v)
                 if(validation == true)
                   config[:parameters][ns_k] = answer
                   valid = true
@@ -215,6 +195,14 @@ module Sfn
           ]
         end
 
+        # Determine if parameter was set via intrinsic function
+        #
+        # @param val [Object]
+        # @return [TrueClass, FalseClass]
+        def function_set_parameter?(val)
+          val.is_a?(Hash)
+        end
+
         # @return [Hash] parameters for root stack create/update
         def config_root_parameters
           Hash[
@@ -280,6 +268,7 @@ module Sfn
         klass.class_eval do
           extend Sfn::CommandModule::Stack::ClassMethods
           include Sfn::CommandModule::Stack::InstanceMethods
+          include Utils::StackParameterValidator
         end
       end