sfn 0.5.0 → 1.0.0

data/lib/sfn/command_module/template.rb

@@ -10,71 +10,33 @@ module Sfn
 
       # cloudformation directories that should be ignored
       TEMPLATE_IGNORE_DIRECTORIES = %w(components dynamics registry)
-      # maximum number of attempts to get valid parameter value
-      MAX_PARAMETER_ATTEMPTS = 5
 
       module InstanceMethods
 
-        # Request compile time parameter value
-        #
-        # @param p_name [String, Symbol] name of parameter
-        # @param p_config [Hash] parameter meta information
-        # @param cur_val [Object, NilClass] current value assigned to parameter
-        # @param nested [TrueClass, FalseClass] template is nested
-        # @option p_config [String, Symbol] :type
-        # @option p_config [String, Symbol] :default
-        # @option p_config [String, Symbol] :description
-        # @option p_config [String, Symbol] :multiple
-        # @return [Object]
-        def request_compile_parameter(p_name, p_config, cur_val, nested=false)
-          result = nil
-          attempts = 0
-          unless(cur_val || p_config[:default].nil?)
-            cur_val = p_config[:default]
-          end
-          if(cur_val.is_a?(Array))
-            cur_val = cur_val.map(&:to_s).join(',')
-          end
-          until(result && (!result.respond_to?(:empty?) || !result.empty?))
-            attempts += 1
-            if(config[:interactive_parameters] && (!nested || !p_config.key?(:prompt_when_nested) || p_config[:prompt_when_nested] == true))
-              result = ui.ask_question(
-                p_name.to_s.split('_').map(&:capitalize).join,
-                :default => cur_val.to_s.empty? ? nil : cur_val.to_s
-              )
-            else
-              result = cur_val.to_s
+        # @return [Array<SparkleFormation::SparklePack>]
+        def sparkle_packs
+          memoize(:sparkle_packs) do
+            config.fetch(:sparkle_pack, []).map do |sparkle_name|
+              SparkleFormation::Sparkle.new(:name => sparkle_name)
             end
-            case p_config.fetch(:type, 'string').to_s.downcase.to_sym
-            when :string
-              if(p_config[:multiple])
-                result = result.split(',').map(&:strip)
-              end
-            when :number
-              if(p_config[:multiple])
-                result = result.split(',').map(&:strip)
-                new_result = result.map do |item|
-                  new_item = item.to_i
-                  new_item if new_item.to_s == item
-                end
-                result = new_result.size == result.size ? new_result : []
-              else
-                new_result = result.to_i
-                result = new_result.to_s == result ? new_result : nil
-              end
-            else
-              raise ArgumentError.new "Unknown compile time parameter type provided: `#{p_config[:type].inspect}` (Parameter: #{p_name})"
+          end
+        end
+
+        # @return [SparkleFormation::SparkleCollection]
+        def sparkle_collection
+          memoize(:sparkle_collection) do
+            collection = SparkleFormation::SparkleCollection.new
+            begin
+              root_pack = SparkleFormation::SparklePack.new(:root => config[:base_directory])
+              collection.set_root(root_pack)
+            rescue Errno::ENOENT
+              ui.warn 'No local SparkleFormation files detected'
             end
-            if(result.nil? || (result.respond_to?(:empty?) && result.empty?))
-              if(attempts > MAX_PARAMETER_ATTEMPTS)
-                ui.fatal 'Failed to receive allowed parameter!'
-                exit 1
-              else
-                ui.error "Invalid value provided for parameter. Must be type: `#{p_config[:type].to_s.capitalize}`"
-              end
+            sparkle_packs.each do |pack|
+              collection.add_sparkle(pack)
             end
+            collection
           end
-          result
         end
 
         # Load the template file
@@ -82,9 +44,10 @@ module Sfn
         # @param args [Symbol] options (:allow_missing)
         # @return [Hash] loaded template
         def load_template_file(*args)
+          c_stack = (args.detect{|i| i.is_a?(Hash)} || {})[:stack]
           unless(config[:template])
             set_paths_and_discover_file!
-            unless(File.exists?(config[:file].to_s))
+            unless(config[:file])
               unless(args.include?(:allow_missing))
                 ui.fatal "Invalid formation file path provided: #{config[:file]}"
                 raise IOError.new "Failed to locate file: #{config[:file]}"
@@ -95,59 +58,110 @@ module Sfn
             config[:template]
           elsif(config[:file])
             if(config[:processing])
-              compile_state = config.fetch(:compile_parameters, Smash.new)
               sf = SparkleFormation.compile(config[:file], :sparkle)
-              if(name_args.first)
-                sf.name = name_args.first
-              end
-              sf.compile_time_parameter_setter do |formation|
-                f_name = []
-                f_form = formation
-                while(f_form)
-                  f_name.push f_form.name
-                  f_form = f_form.parent
-                end
-                f_name = f_name.reverse.map(&:to_s).join('_')
-                current_state = compile_state.fetch(f_name, Smash.new)
-                if(formation.compile_state)
-                  current_state = current_state.merge(formation.compile_state)
-                end
-                ui.info "#{ui.color('Compile time parameters:', :bold)} - template: #{ui.color(formation.name, :green, :bold)}"
-                formation.parameters.each do |k,v|
-                  current_state[k] = request_compile_parameter(k, v, current_state[k], !!formation.parent)
-                end
-                formation.compile_state = current_state
+              sparkle_packs.each do |pack|
+                sf.sparkle.add_sparkle(pack)
               end
               if(sf.nested? && !sf.isolated_nests?)
-                raise TypeError.new('Template does not contain isolated stack nesting! Cannot process in existing state.')
+                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])
-                sf.apply_nesting do |stack_name, stack_definition|
-                  if(config[:print_only])
-                    # "http://example.com/bucket/#{name_args.first}_#{stack_name}.json"
-                    stack_definition
-                  else
-                    bucket = provider.connection.api_for(:storage).buckets.get(
-                      config[:nesting_bucket]
-                    )
-                    unless(bucket)
-                      raise "Failed to locate configured bucket for stack template storage (#{bucket})!"
-                    end
-                    file = bucket.files.build
-                    file.name = "#{name_args.first}_#{stack_name}.json"
-                    file.content_type = 'text/json'
-                    file.body = MultiJson.dump(Sfn::Utils::StackParameterScrubber.scrub!(stack_definition))
-                    file.save
-                    # TODO: what if we need extra params?
-                    url = URI.parse(file.url)
-                    "#{url.scheme}://#{url.host}#{url.path}"
-                  end
+                if(config[:apply_nesting] == true)
+                  config[:apply_nesting] = :deep
+                end
+                case config[:apply_nesting].to_sym
+                when :deep
+                  process_nested_stack_deep(sf, c_stack)
+                when :shallow
+                  process_nested_stack_shallow(sf, c_stack)
+                else
+                  raise ArgumentError.new "Unknown nesting style requested: #{config[:apply_nesting].inspect}!"
                 end
               else
                 sf.dump.merge('sfn_nested_stack' => !!sf.nested?)
               end
             else
-              _from_json(File.read(config[:file]))
+              template = _from_json(File.read(config[:file]))
+              run_callbacks_for(:template, :stack_name => arguments.first, :hash_stack => template)
+              template
+            end
+          else
+            raise ArgumentError.new 'Failed to locate template for processing!'
+          end
+        end
+
+        # Processes template using the original shallow workflow
+        #
+        # @param sf [SparkleFormation] stack formation
+        # @param c_stack [Miasma::Models::Orchestration::Stack] existing stack
+        # @return [Hash] dumped stack
+        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
+              resource.properties.delete!(:stack)
+              unless(bucket)
+                raise "Failed to locate configured bucket for stack template storage (#{bucket})!"
+              end
+              file = bucket.files.build
+              file.name = "#{name_args.first}_#{stack_name}.json"
+              file.content_type = 'text/json'
+              file.body = MultiJson.dump(Sfn::Utils::StackParameterScrubber.scrub!(stack_definition))
+              file.save
+              url = URI.parse(file.url)
+              template_url = "#{url.scheme}://#{url.host}#{url.path}"
+            end
+            resource.properties.set!('TemplateURL', template_url)
+          end
+        end
+
+        # Processes template using new deep workflow
+        #
+        # @param sf [SparkleFormation] stack
+        # @param c_stack [Miasma::Models::Orchestration::Stack] existing stack
+        # @return [Hash] dumped stack
+        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_definition = stack.compile.dump!
+            stack_resource = resource._dump
+            unless(config[:print_only])
+              result = Smash.new(
+                'Parameters' => populate_parameters!(stack,
+                  :stack => c_stack ? c_stack.nested_stacks.detect{|s| s.data[:logical_id] == stack_name} : nil,
+                  :current_parameters => c_stack ? c_stack.template.fetch('Resources', stack_name, 'Properties', 'Parameters', Smash.new) : stack_resource['Properties'].fetch('Parameters', {})
+                )
+              )
+              resource.properties.delete!(:stack)
+              bucket = provider.connection.api_for(:storage).buckets.get(
+                config[:nesting_bucket]
+              )
+              unless(bucket)
+                raise "Failed to locate configured bucket for stack template storage (#{bucket})!"
+              end
+              file = bucket.files.build
+              file.name = "#{name_args.first}_#{stack_name}.json"
+              file.content_type = 'text/json'
+              file.body = MultiJson.dump(Sfn::Utils::StackParameterScrubber.scrub!(stack_definition))
+              file.save
+              url = URI.parse(file.url)
+              result.merge!(
+                'TemplateURL' => "#{url.scheme}://#{url.host}#{url.path}"
+              )
+            else
+              result = Smash.new(
+                'TemplateURL' => "http://example.com/bucket/#{name_args.first}_#{stack_name}.json"
+              )
+            end
+            result.each do |k,v|
+              resource.properties.set!(k, v)
             end
           end
         end
@@ -181,40 +195,98 @@ module Sfn
         #
         # @return [TrueClass]
         def set_paths_and_discover_file!
-          if(config[:base_directory])
-            SparkleFormation.sparkle_path = config[:base_directory]
-          end
-          if(!config[:file] && config[:file_path_prompt])
-            root = File.expand_path(
-              config.fetch(:base_directory,
-                File.join(Dir.pwd, 'cloudformation')
-              )
-            ).split('/')
-            bucket = root.pop
-            root = root.join('/')
-            directory = File.join(root, bucket)
-            config[:file] = prompt_for_file(directory,
-              :directories_name => 'Collections',
-              :files_name => 'Templates',
-              :ignore_directories => TEMPLATE_IGNORE_DIRECTORIES
-            )
+          if(config[:processing])
+            if(!config[:file] && config[:file_path_prompt])
+              config[:file] = prompt_for_template
+            else
+              config[:file] = sparkle_collection.get(:template, config[:file])[:path]
+            end
           else
-            unless(Pathname(config[:file].to_s).absolute?)
-              base_dir = config[:base_directory].to_s
-              file = config[:file].to_s
-              pwd = Dir.pwd
-              config[:file] = [
-                File.join(base_dir, file),
-                File.join(pwd, file),
-                File.join(pwd, 'cloudformation', file)
-              ].detect do |file_path|
-                File.file?(file_path)
+            if(config[:file])
+              unless(File.exists?(config[:file]))
+                raise Errno::ENOENT.new("No such file - #{config[:file]}")
               end
+            else
+              raise "Template processing is disabled. Path to serialized template via `--file` required!"
             end
           end
           true
         end
 
+        # Prompt user for template selection
+        #
+        # @param prefix [String] prefix filter for names
+        # @return [String] path to template
+        def prompt_for_template(prefix=nil)
+          if(prefix)
+            collection_name = prefix.split('__').map do |c_name|
+              c_name.split('_').map(&:capitalize).join(' ')
+            end.join(' / ')
+            ui.info "Viewing collection: #{ui.color(collection_name, :bold)}"
+            template_names = sparkle_collection.templates.keys.find_all do |t_name|
+              t_name.to_s.start_with?(prefix.to_s)
+            end
+          else
+            template_names = sparkle_collection.templates.keys
+          end
+          collections = template_names.map do |t_name|
+            t_name = t_name.to_s.sub(/^#{Regexp.escape(prefix.to_s)}/, '')
+            if(t_name.include?('__'))
+              c_name = t_name.split('__').first
+              [[prefix, c_name].compact.join('') + '__', c_name]
+            end
+          end.compact.uniq(&:first)
+          templates = template_names.map do |t_name|
+            t_name = t_name.to_s.sub(/^#{Regexp.escape(prefix.to_s)}/, '')
+            unless(t_name.include?('__'))
+              [[prefix, t_name].compact.join(''), t_name]
+            end
+          end.compact
+          if(collections.empty? && templates.empty?)
+            ui.error 'Failed to locate any templates!'
+            return nil
+          end
+          ui.info "Please select an entry#{ '(or collection to list)' unless collections.empty?}:"
+          output = []
+          idx = 1
+          valid = {}
+          unless(collections.empty?)
+            output << ui.color('Collections:', :bold)
+            collections.each do |full_name, part_name|
+              valid[idx] = {:name => full_name, :type => :collection}
+              output << [idx, part_name.split('_').map(&:capitalize).join(' ')]
+              idx += 1
+            end
+          end
+          unless(templates.empty?)
+            output << ui.color('Templates:', :bold)
+            templates.each do |full_name, part_name|
+              valid[idx] = {:name => full_name, :type => :template}
+              output << [idx, part_name.split('_').map(&:capitalize).join(' ')]
+              idx += 1
+            end
+          end
+          max = idx.to_s.length
+          output.map! do |line|
+            if(line.is_a?(Array))
+              "  #{line.first}.#{' ' * (max - line.first.to_s.length)} #{line.last}"
+            else
+              line
+            end
+          end
+          ui.puts "#{output.join("\n")}\n"
+          response = nil
+          until(valid[response])
+            response = ui.ask_question('Enter selection').to_i
+          end
+          entry = valid[response]
+          if(entry[:type] == :collection)
+            prompt_for_template(entry[:name])
+          else
+            sparkle_collection.get(:template, entry[:name])[:path]
+          end
+        end
+
       end
 
       module ClassMethods

data/lib/sfn/command_module.rb

@@ -3,6 +3,7 @@ require 'sfn'
 module Sfn
   module CommandModule
     autoload :Base, 'sfn/command_module/base'
+    autoload :Callbacks, 'sfn/command_module/callbacks'
     autoload :Stack, 'sfn/command_module/stack'
     autoload :Template, 'sfn/command_module/template'
   end

data/lib/sfn/config/update.rb

@@ -5,10 +5,6 @@ module Sfn
     # Update command configuration
     class Update < Validate
 
-      attribute(
-        :print_only, [TrueClass, FalseClass],
-        :description => 'Print the resulting stack template'
-      )
       attribute(
         :apply_stack, String,
         :multiple => true,

data/lib/sfn/config/validate.rb

@@ -37,14 +37,24 @@ module Sfn
         :coerce => lambda{|v| v.to_i}
       )
       attribute(
-        :apply_nesting, [TrueClass, FalseClass],
-        :default => true,
+        :apply_nesting, [String, Symbol],
+        :default => 'deep',
         :description => 'Apply stack nesting'
       )
       attribute(
         :nesting_bucket, String,
         :description => 'Bucket to use for storing nested stack templates'
       )
+      attribute(
+        :print_only, [TrueClass, FalseClass],
+        :description => 'Print the resulting stack template'
+      )
+      attribute(
+        :sparkle_pack, String,
+        :multiple => true,
+        :description => 'Load SparklePack gem',
+        :coerce => lambda{|s| require s; s}
+      )
 
     end
   end

data/lib/sfn/monkey_patch/stack.rb

@@ -187,6 +187,78 @@ module Sfn
         end
       end
 
+      # Return all stacks contained within this stack
+      #
+      # @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|
+          if(self.api.class.const_get(:RESOURCE_MAPPING).fetch(resource.type, {})[:api] == :orchestration)
+            n_stack = resource.expand
+            if(n_stack)
+              n_stack.data[:logical_id] = resource.name
+              n_stack.data[:parent_stack] = self
+              if(recurse)
+                [n_stack] + n_stack.nested_stacks(recurse)
+              else
+                n_stack
+              end
+            end
+          end
+        end.flatten.compact
+      end
+
+      # @return [TrueClass, FalseClass] stack contains nested stacks
+      def nested?
+        !!resources.detect do |resource|
+          self.api.class.const_get(:RESOURCE_MAPPING).fetch(resource.type, {})[:api] == :orchestration
+        end
+      end
+
+      # Return stack policy if available
+      #
+      # @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
+              )
+            )
+            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
+
+      # Detect the nesting style in use by the stack
+      #
+      # @return [Symbol, NilClass] style of nesting (:shallow, :deep)
+      #   or `nil` if no nesting detected
+      # @note in shallow nesting style, stack resources will not
+      #   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
+        end
+      end
+
     end
   end
 end

data/lib/sfn/utils/path_selector.rb

@@ -1,4 +1,5 @@
 require 'sfn'
+require 'pathname'
 
 module Sfn
   module Utils
@@ -87,6 +88,8 @@ module Sfn
             entry = valid[response.to_i]
             if(entry[:type] == :directory)
               prompt_for_file(entry[:path], opts)
+            elsif Pathname(entry[:path]).absolute?
+              entry[:path]
             else
               "/#{entry[:path]}"
             end

data/lib/sfn/version.rb

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

data/lib/sfn.rb

@@ -4,6 +4,7 @@ require 'bogo'
 
 module Sfn
 
+  autoload :Callback, 'sfn/callback'
   autoload :Provider, 'sfn/provider'
   autoload :Cache, 'sfn/cache'
   autoload :Config, 'sfn/config'

data/sfn.gemspec

@@ -11,24 +11,22 @@ Gem::Specification.new do |s|
   s.license = 'Apache-2.0'
   s.require_path = 'lib'
   s.add_dependency 'bogo-cli', '~> 0.1.21'
-  s.add_dependency 'miasma', '~> 0.2.20'
+  s.add_dependency 'miasma', '~> 0.2.27'
   s.add_dependency 'miasma-aws', '~> 0.1.16'
   s.add_dependency 'net-ssh'
-  s.add_dependency 'sparkle_formation', '>= 0.4.0', '< 1.0'
+  s.add_dependency 'sparkle_formation', '~> 1.0'
   s.executables << 'sfn'
   s.files = Dir['{lib,bin}/**/*'] + %w(sfn.gemspec README.md CHANGELOG.md LICENSE)
   s.post_install_message = <<-EOF
 
-This version of sfn restricts the SparkleFormation library to versions prior to the
-1.0 release. That's great for now but it means many features will not be available
-and only fixes will be backported and applied to this gem.
+This is an install of the sfn gem from the 1.0 release tree. If you
+are upgrading from a pre-1.0 version, please review the CHANGELOG and
+test your environment _before_ continuing on!
 
-It is highly suggested that you upgrade to the 1.0 version of sfn or later to take
-advantage of new features and new development. This gem will continue on in
-maintenance mode for the near term future. Once EOL has been reached, this message
-will be updated.
+* https://github.com/sparkleformation/sfn/blob/master/CHANGELOG.md
+
+Happy stacking!
 
-Thanks and happy stacking!
 EOF
 
 end