sfn 2.2.0 → 3.0.0

data/lib/sfn/command_module/template.rb

@@ -15,6 +15,23 @@ module Sfn
 
       module InstanceMethods
 
+        # Extract template content based on type
+        #
+        # @param thing [SparkleFormation, Hash]
+        # @param scrub [Truthy, Falsey] scrub nested templates
+        # @return [Hash]
+        def template_content(thing, scrub=false)
+          if(thing.is_a?(SparkleFormation))
+            if(scrub)
+              dump_stack_for_storage(thing)
+            else
+              config[:sparkle_dump] ? thing.sparkle_dump : thing.dump
+            end
+          else
+            thing
+          end
+        end
+
         # Request compile time parameter value
         #
         # @param p_name [String, Symbol] name of parameter
@@ -70,7 +87,7 @@ module Sfn
                 ui.fatal "Failed to receive allowed parameter! (Parameter: #{p_name})"
                 exit 1
               else
-                ui.error "Invalid value provided for parameter. Must be type: `#{p_config[:type].to_s.capitalize}`"
+                ui.error "Invalid value provided for parameter `#{p_name}`. Must be type: `#{p_config[:type].to_s.capitalize}`"
               end
             end
           end
@@ -100,12 +117,19 @@ module Sfn
         # @return [SparkleFormation::SparkleCollection]
         def sparkle_collection
           memoize(:sparkle_collection) do
-            collection = SparkleFormation::SparkleCollection.new
+            collection = SparkleFormation::SparkleCollection.new(
+              :provider => config.get(:credentials, :provider)
+            )
             begin
               if(config[:base_directory])
-                root_pack = SparkleFormation::SparklePack.new(:root => config[:base_directory])
+                root_pack = SparkleFormation::SparklePack.new(
+                  :root => config[:base_directory],
+                  :provider => config.get(:credentials, :provider)
+                )
               else
-                root_pack = SparkleFormation::SparklePack.new
+                root_pack = SparkleFormation::SparklePack.new(
+                  :provider => config.get(:credentials, :provider)
+                )
               end
               collection.set_root(root_pack)
             rescue Errno::ENOENT
@@ -175,9 +199,6 @@ module Sfn
                   sf.stack_resource_types.push(s_type)
                 end
               end
-              if(sf.nested? && !sf.isolated_nests?)
-                raise TypeError.new('Template does not contain isolated stack nesting! Sfn does not support mixed mixed resources within root stack!')
-              end
               run_callbacks_for(:template, :stack_name => arguments.first, :sparkle_stack => sf)
               if(sf.nested? && config[:apply_nesting])
                 validate_nesting_bucket!
@@ -190,12 +211,13 @@ module Sfn
                 when :shallow
                   process_nested_stack_shallow(sf, c_stack)
                 when :none
-                  sf.dump.merge('sfn_nested_stack' => !!sf.nested?)
+                  sf
                 else
                   raise ArgumentError.new "Unknown nesting style requested: #{config[:apply_nesting].inspect}!"
                 end
+                sf
               else
-                sf.dump.merge('sfn_nested_stack' => !!sf.nested?)
+                sf
               end
             else
               template = _from_json(File.read(config[:file]))
@@ -249,20 +271,13 @@ module Sfn
         #
         # @param sf [SparkleFormation] stack
         # @param c_stack [Miasma::Models::Orchestration::Stack] existing stack
-        # @return [Hash] dumped stack
+        # @return [SparkleFormation::SparkleStruct] compiled structure
         def process_nested_stack_deep(sf, c_stack=nil)
           sf.apply_nesting(:deep) do |stack_name, stack, resource|
             run_callbacks_for(:template, :stack_name => stack_name, :sparkle_stack => stack)
-
             stack_resource = resource._dump
-
-            if(stack.parent)
-              current_parameters = stack.parent.compile.resources.set!(stack_name).properties.parameters
-              current_parameters = current_parameters.nil? ? Smash.new : current_parameters._dump
-            else
-              current_parameters = Smash.new
-            end
             current_stack = c_stack ? c_stack.nested_stacks.detect{|s| s.data[:logical_id] == stack_name} : nil
+            current_parameters = extract_current_nested_template_parameters(stack, stack_name, current_stack)
             if(current_stack && current_stack.data[:parent_stack])
               current_parameters.merge!(
                 current_stack.data[:parent_stack].template.fetch(
@@ -283,21 +298,7 @@ module Sfn
                   :current_parameters => current_parameters
                 )
               )
-              stack_definition = dump_stack_for_storage(stack)
-              bucket = provider.connection.api_for(:storage).buckets.get(
-                config[:nesting_bucket]
-              )
-              unless(bucket)
-                raise "Failed to locate configured bucket for stack template storage (#{config[:nesting_bucket]})!"
-              end
-              file = bucket.files.build
-              file.name = "#{full_stack_name}.json"
-              file.content_type = 'text/json'
-              file.body = MultiJson.dump(Sfn::Utils::StackParameterScrubber.scrub!(stack_definition))
-              file.save
-              result.merge!(
-                :url => file.url
-              )
+              store_template(full_stack_name, stack, result)
             else
               result = Smash.new(
                 :url => "http://example.com/bucket/#{full_stack_name}.json"
@@ -309,6 +310,45 @@ module Sfn
           end
         end
 
+        # Extract currently defined parameters for nested template
+        #
+        # @param stack [SparkleFormation]
+        # @param stack_name [String]
+        # @param c_stack [Miasma::Models::Orchestration::Stack]
+        # @return [Hash]
+        def extract_current_nested_template_parameters(stack, stack_name, c_stack=nil)
+          if(stack.parent)
+            current_parameters = stack.parent.compile.resources.set!(stack_name).properties.parameters
+            current_parameters.nil? ? Smash.new : current_parameters._dump
+          else
+            Smash.new
+          end
+        end
+
+        # Store template in remote bucket and update given result hash
+        #
+        # @param full_stack_name [String] unique resource name for template
+        # @param stack [SparkleFormation] template instance
+        # @param result [Hash]
+        # @return [Hash]
+        def store_template(full_stack_name, stack, result)
+          stack_definition = stack.is_a?(SparkleFormation) ? dump_stack_for_storage(stack) : stack
+          bucket = provider.connection.api_for(:storage).buckets.get(
+            config[:nesting_bucket]
+          )
+          unless(bucket)
+            raise "Failed to locate configured bucket for stack template storage (#{config[:nesting_bucket]})!"
+          end
+          file = bucket.files.build
+          file.name = "#{full_stack_name}.json"
+          file.content_type = 'text/json'
+          file.body = MultiJson.dump(parameter_scrub!(stack_definition))
+          file.save
+          result.merge!(
+            :url => file.url
+          )
+        end
+
         # Remove internally used `Stack` property from Stack resources and
         # and generate compiled Hash
         #
@@ -522,6 +562,7 @@ module Sfn
           extend Sfn::CommandModule::Template::ClassMethods
           include Sfn::CommandModule::Template::InstanceMethods
           include Sfn::Utils::PathSelector
+          include Sfn::Utils::StackParameterScrubber
          end
       end
 

data/lib/sfn/config/print.rb

@@ -11,6 +11,11 @@ module Sfn
         :short_flag => 'w'
       )
 
+      attribute(
+        :sparkle_dump, [TrueClass, FalseClass],
+        :description => 'Do not use provider customized dump behavior'
+      )
+
     end
   end
 end

data/lib/sfn/config/update.rb

@@ -11,6 +11,10 @@ module Sfn
         :description => 'Apply outputs from stack to input parameters',
         :short_flag => 'A'
       )
+      attribute(
+        :apply_mapping, Smash,
+        :description => 'Customize apply stack mapping as [StackName__]OutputName:ParameterName'
+      )
       attribute(
         :parameter, Smash,
         :multiple => true,

data/lib/sfn/config/validate.rb

@@ -94,6 +94,10 @@ module Sfn
           end
         }
       )
+      attribute(
+        :upload_root_template, [TrueClass, FalseClass],
+        :description => 'Upload root template to storage bucket'
+      )
 
     end
   end

data/lib/sfn/monkey_patch/stack.rb

@@ -7,7 +7,12 @@ module Sfn
     # Expand stack model functionality
     module Stack
 
+      autoload :Azure, 'sfn/monkey_patch/stack/azure'
+      autoload :Google, 'sfn/monkey_patch/stack/google'
+
       include Bogo::AnimalStrings
+      include Azure
+      include Google
 
       ## Status helpers
 
@@ -135,58 +140,85 @@ module Sfn
       # @param min [Integer] lowest allowed return value (defaults 5)
       # @return [Integer] percent complete (0..100)
       def percent_complete(min = 5)
-        if(in_progress?)
-          total_resources = template.fetch('Resources', []).size
-          total_complete = resources.all.find_all do |resource|
-            resource.status.downcase.end_with?('complete')
-          end.size
-          result = ((total_complete.to_f / total_resources) * 100).to_i
-          result > min.to_i ? result : min
+        if(self.respond_to?("percent_complete_#{api.provider}"))
+          self.send("percent_complete_#{api.provider}", min)
         else
-          100
+          if(in_progress?)
+            total_resources = template.fetch('Resources', []).size
+            total_complete = resources.all.find_all do |resource|
+              resource.status.downcase.end_with?('complete')
+            end.size
+            result = ((total_complete.to_f / total_resources) * 100).to_i
+            result > min.to_i ? result : min
+          else
+            100
+          end
         end
       end
 
       # Apply stack outputs to current stack parameters
       #
+      # @param opts [Hash]
+      # @option opts [String] :parameter_key key used for parameters block
+      # @option opts [String] :default_key key used within parameter for default value
+      # @option opts [Hash] :mapping custom output -> parameter name mapping
       # @param remote_stack [Miasma::Orchestration::Stack]
       # @return [self]
       # @note setting `DisableApply` within parameter hash will
       #   prevent parameters being overridden
-      def apply_stack(remote_stack, ignore_params=nil)
-        default_key = 'Default'
-        stack_parameters = template['Parameters']
-        if(stack_parameters)
-          valid_parameters = Smash[
-            stack_parameters.map do |key, val|
-              unless(val['DisableApply'])
-                [snake(key), key]
-              end
-            end.compact
-          ]
-          if(ignore_params)
-            valid_parameters = Hash[
-              valid_parameters.map do |snake_param, camel_param|
-                unless(ignore_params.include?(camel_param))
-                  [snake_param, camel_param]
-                end
-              end.compact
-            ]
+      def apply_stack(remote_stack, opts={}, ignore_params=nil)
+        if(self.respond_to?("apply_stack_#{api.provider}"))
+          self.send("apply_stack_#{api.provider}", remote_stack, opts, ignore_params)
+        else
+          unless(opts[:mapping])
+            opts[:mapping] = {}
           end
-          if(persisted?)
-            remote_stack.outputs.each do |output|
-              if(param_key = valid_parameters[snake(output.key)])
-                parameters.merge!(param_key => output.value)
+          if(opts[:parameter_key])
+            stack_parameters = template[opts[:parameter_key]]
+            default_key = opts.fetch(
+              :default_key,
+              opts[:parameter_key].to_s[0,1].match(/[a-z]/) ? 'default' : 'Default'
+            )
+          else
+            if(template['Parameters'])
+              default_key = 'Default'
+              stack_parameters = template['Parameters']
+            else
+              default_key = 'default'
+              stack_parameters = template['parameters']
+            end
+          end
+          if(stack_parameters)
+            valid_parameters = stack_parameters.find_all do |key, val|
+              !val['DisableApply'] && !val['disable_apply']
+            end.map(&:first)
+            if(ignore_params)
+              valid_parameters.reject! do |key|
+                ignore_params.include?(key)
               end
             end
-          else
             remote_stack.outputs.each do |output|
-              if(param_key = valid_parameters[snake(output.key)])
-                stack_parameters[param_key][default_key] = output.value
+              o_key = output.key.downcase.tr('_', '')
+              p_key = valid_parameters.detect do |v_param|
+                v_param.downcase.tr('_', '') == o_key
+              end
+              unless(p_key)
+                map_key = opts[:mapping].keys.detect do |map_key|
+                  map_key.downcase.tr('_', '') == o_key
+                end
+                if(map_key)
+                  p_key = valid_parameters.detect do |v_param|
+                    v_param.downcase.tr('_', '') == opts[:mapping][map_key].downcase.tr('_', '')
+                  end
+                end
+              end
+              if(p_key)
+                parameters.merge!(p_key => output.value)
               end
             end
           end
         end
+        self
       end
 
       # Return all stacks contained within this stack
@@ -194,39 +226,47 @@ module Sfn
       # @param recurse [TrueClass, FalseClass] recurse to fetch _all_ stacks
       # @return [Array<Miasma::Models::Orchestration::Stack>]
       def nested_stacks(recurse=true)
-        resources.reload.all.map do |resource|
-          if(api.data.fetch(:stack_types, []).include?(resource.type))
-            # Custom remote load support
-            if(resource.type == 'Custom::JackalStack')
-              location, stack_id = resource.id.to_s.split('-', 2)
-              if(l_conf = api.data[:locations][location])
-                n_stack = Miasma.api(
-                  :type => :orchestration,
-                  :provider => l_conf[:provider],
-                  :credentials => l_conf
-                ).stacks.get(stack_id)
-              end
-            else
-              n_stack = resource.expand
-            end
-            if(n_stack)
-              n_stack.data[:logical_id] = resource.name
-              n_stack.data[:parent_stack] = self
-              n_stack.api.data[:stack_types] = api.data[:stack_types]
-              if(recurse)
-                [n_stack] + n_stack.nested_stacks(recurse)
+        if(self.respond_to?("nested_stacks_#{api.provider}"))
+          self.send("nested_stacks_#{api.provider}", recurse)
+        else
+          resources.reload.all.map do |resource|
+            if(api.data.fetch(:stack_types, []).include?(resource.type))
+              # Custom remote load support
+              if(resource.type == 'Custom::JackalStack')
+                location, stack_id = resource.id.to_s.split('-', 2)
+                if(l_conf = api.data[:locations][location])
+                  n_stack = Miasma.api(
+                    :type => :orchestration,
+                    :provider => l_conf[:provider],
+                    :credentials => l_conf
+                  ).stacks.get(stack_id)
+                end
               else
-                n_stack
+                n_stack = resource.expand
+              end
+              if(n_stack)
+                n_stack.data[:logical_id] = resource.name
+                n_stack.data[:parent_stack] = self
+                n_stack.api.data[:stack_types] = api.data[:stack_types]
+                if(recurse)
+                  [n_stack] + n_stack.nested_stacks(recurse)
+                else
+                  n_stack
+                end
               end
             end
-          end
-        end.flatten.compact
+          end.flatten.compact
+        end
       end
 
       # @return [TrueClass, FalseClass] stack contains nested stacks
       def nested?
-        !!resources.detect do |resource|
-          api.data.fetch(:stack_types, []).include?(resource.type)
+        if(self.respond_to?("nested_#{api.provider}?"))
+          self.send("nested_#{api.provider}?")
+        else
+          !!resources.detect do |resource|
+            api.data.fetch(:stack_types, []).include?(resource.type)
+          end
         end
       end
 
@@ -234,22 +274,26 @@ module Sfn
       #
       # @return [Smash, NilClass]
       def policy
-        if(self.api.provider == :aws) # cause this is the only one
-          begin
-            result = self.api.request(
-              :path => '/',
-              :form => Smash.new(
-                'Action' => 'GetStackPolicy',
-                'StackName' => self.id
+        if(self.respond_to?("policy_#{api.provider}"))
+          self.send("policy_#{api.provider}")
+        else
+          if(self.api.provider == :aws) # cause this is the only one
+            begin
+              result = self.api.request(
+                :path => '/',
+                :form => Smash.new(
+                  'Action' => 'GetStackPolicy',
+                  'StackName' => self.id
+                )
               )
-            )
-            serialized_policy = result.get(:body, 'GetStackPolicyResult', 'StackPolicyBody')
-            MultiJson.load(serialized_policy).to_smash
-          rescue Miasma::Error::ApiError::RequestError => e
-            if(e.response.code == 404)
-              nil
-            else
-              raise
+              serialized_policy = result.get(:body, 'GetStackPolicyResult', 'StackPolicyBody')
+              MultiJson.load(serialized_policy).to_smash
+            rescue Miasma::Error::ApiError::RequestError => e
+              if(e.response.code == 404)
+                nil
+              else
+                raise
+              end
             end
           end
         end
@@ -263,14 +307,40 @@ module Sfn
       #   contain any direct values for parameters (which is what we
       #   are testing for)
       def nesting_style
-        if(nested?)
-          self.template['Resources'].find_all do |t_resource|
-            t_resource['Type'] == self.api.class.const_get(:RESOURCE_MAPPING).key(self.class)
-          end.detect do |t_resource|
-            t_resource['Properties'].fetch('Parameters', {}).values.detect do |t_value|
-              !t_value.is_a?(Hash)
-            end
-          end ? :deep : :shallow
+        if(self.respond_to?("nesting_style_#{api.provider}"))
+          self.send("nesting_style_#{api.provider}")
+        else
+          if(nested?)
+            self.template['Resources'].find_all do |t_resource|
+              t_resource['Type'] == self.api.class.const_get(:RESOURCE_MAPPING).key(self.class)
+            end.detect do |t_resource|
+              t_resource['Properties'].fetch('Parameters', {}).values.detect do |t_value|
+                !t_value.is_a?(Hash)
+              end
+            end ? :deep : :shallow
+          end
+        end
+      end
+
+      # Reformat template data structure to SparkleFormation style structure
+      #
+      # @return [Hash]
+      def sparkleish_template(*args)
+        if(self.respond_to?("sparkleish_template_#{api.provider}"))
+          self.send("sparkleish_template_#{api.provider}", *args)
+        else
+          template
+        end
+      end
+
+      # Provide easy parameters override
+      #
+      # @return [Hash]
+      def root_parameters
+        if(self.respond_to?("root_parameters_#{api.provider}"))
+          self.send("root_parameters_#{api.provider}")
+        else
+          parameters
         end
       end