knife-cloudformation 0.1.2 → 0.1.4

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## v0.1.4
+* Support outputs on stack creation
+* Poll on destroy by default
+* Add inspection helper for failed node inspection
+* Refactor AWS interactions to common library
+
 ## v0.1.2
 * Update dependency restriction to get later version
 

data/lib/chef/knife/cloudformation_base.rb

@@ -1,85 +1,15 @@
 require 'chef/knife'
+require 'knife-cloudformation/utils'
+require 'knife-cloudformation/aws_commons'
 
-class Chef
-  class Knife
+module KnifeCloudformation
 
-    # Populate up the hashes so they are available for knife config
-    # with issues of nils
-    ['knife.cloudformation.credentials', 'knife.cloudformation.options'].each do |stack|
-      stack.split('.').inject(Chef::Config) do |memo, item|
-        memo[item.to_sym] = Mash.new unless memo[item.to_sym]
-        memo[item.to_sym]
-      end
-    end
-    
-    Chef::Config[:knife][:cloudformation] ||= Mash.new
-    
-    module CloudformationDefault
-      class << self
-        def included(klass)
-          klass.instance_eval do
-            deps do
-              require 'fog'
-              Chef::Config[:knife][:cloudformation] ||= Mash.new
-              Chef::Config[:knife][:cloudformation][:credentials] ||= Mash.new
-              Chef::Config[:knife][:cloudformation][:options] ||= Mash.new
-            end
-
-            option(:key,
-              :short => '-K KEY',
-              :long => '--key KEY',
-              :description => 'AWS access key id',
-              :proc => lambda {|val|
-                Chef::Config[:knife][:cloudformation][:credentials][:key] = val
-              }
-            )
-            option(:secret,
-              :short => '-S SECRET',
-              :long => '--secret SECRET',
-              :description => 'AWS secret access key',
-              :proc => lambda {|val|
-                Chef::Config[:knife][:cloudformation][:credentials][:secret] = val
-              }
-            )
-            option(:region,
-              :short => '-r REGION',
-              :long => '--region REGION',
-              :description => 'AWS region',
-              :proc => lambda {|val|
-                Chef::Config[:knife][:cloudformation][:credentials][:region] = val
-              }
-            )
-          end
-        end
-      end
-    end
-
-    class CloudformationBase < Knife
-
-      class << self
-        def aws_con
-          @connection ||= Fog::AWS::CloudFormation.new(
-            :aws_access_key_id => _key,
-            :aws_secret_access_key => _secret,
-            :region => _region
-          )
-        end
-
-        def _key
-          Chef::Config[:knife][:cloudformation][:credentials][:key] ||
-            Chef::Config[:knife][:aws_access_key_id]
-        end
-
-        def _secret
-          Chef::Config[:knife][:cloudformation][:credentials][:secret] ||
-            Chef::Config[:knife][:aws_secret_access_key]
-        end
+  module KnifeBase
 
-        def _region
-          Chef::Config[:knife][:cloudformation][:credentials][:region] ||
-            Chef::Config[:knife][:region]
-        end
+    module InstanceMethods
 
+      def aws
+        self.class.con(ui)
       end
 
       def _debug(e, *args)
@@ -91,43 +21,8 @@ class Chef
         end
       end
 
-      def aws_con
-        self.class.aws_con
-      end
-      
-      def stack_status(name)
-        aws_con.describe_stacks('StackName' => name).body['Stacks'].first['StackStatus']
-      end
-
-      def get_titles(thing, format=false)
-        unless(@titles)
-          attrs = allowed_attributes
-          if(attrs.empty?)
-            hash = thing.is_a?(Array) ? thing.first : thing
-            hash ||= {}
-            attrs = hash.keys
-          end
-          @titles = attrs.map do |key|
-            next unless attribute_allowed?(key)
-            key.gsub(/([a-z])([A-Z])/, '\1 \2')
-          end.compact
-        end
-        if(format)
-          @titles.map{|s| ui.color(s, :bold)}
-        else
-          @titles
-        end
-      end
-
-      def process(things)
-        @event_ids ||= []
-        things.reverse.map do |thing|
-          next if @event_ids.include?(thing['EventId'])
-          @event_ids.push(thing['EventId']).compact!
-          get_titles(thing).map do |key|
-            thing[key.gsub(' ', '')].to_s
-          end
-        end.flatten.compact
+      def stack(name)
+        self.class.con(ui).stack(name)
       end
 
       def allowed_attributes
@@ -142,15 +37,27 @@ class Chef
         config[:all_attributes] || allowed_attributes.include?(attr)
       end
 
-      def things_output(stack, things, what)
-        output = get_titles(things, :format)
-        output += process(things)
+      def poll_stack(name)
+        knife_events = Chef::Knife::CloudformationEvents.new
+        knife_events.name_args.push(name)
+        Chef::Config[:knife][:cloudformation][:poll] = true
+        knife_events.run
+      end
+
+      def things_output(stack, things, what, *args)
+        unless(args.include?(:no_title))
+          output = aws.get_titles(things, :format => true, :attributes => allowed_attributes)
+        else
+          output = []
+        end
+        columns = allowed_attributes.size
+        output += aws.process(things, :flat => true, :attributes => allowed_attributes)
         output.compact.flatten
-        if(output.empty?)
+        if(output.empty? && !args.include?(:ignore_empty_output))
           ui.warn 'No information found'
         else
           ui.info "#{what.to_s.capitalize} for stack: #{ui.color(stack, :bold)}" if stack
-          ui.info "#{ui.list(output, :uneven_columns_across, get_titles(things).size)}\n"
+          ui.info "#{ui.list(output, :uneven_columns_across, columns)}"
         end
       end
 
@@ -165,38 +72,97 @@ class Chef
         end
       end
 
-      def try_json_compat
-        begin
-          require 'chef/json_compat'
-        rescue
+    end
+
+    module ClassMethods
+
+      def con(ui=nil)
+        unless(@common)
+          @common = KnifeCloudformation::AwsCommons.new(
+            :ui => ui,
+            :fog => {
+              :aws_access_key_id => _key,
+              :aws_secret_access_key => _secret,
+              :region => _region
+            }
+          )
         end
-        defined?(Chef::JSONCompat)
+        @common
       end
-      
-      def _to_json(thing)
-        if(try_json_compat)
-          Chef::JSONCompat.to_json(thing)
-        else
-          JSON.dump(thing)
-        end
+
+      def _key
+        Chef::Config[:knife][:cloudformation][:credentials][:key] ||
+          Chef::Config[:knife][:aws_access_key_id]
       end
 
-      def _from_json(thing)
-        if(try_json_compat)
-          Chef::JSONCompat.from_json(thing)
-        else
-          JSON.read(thing)
-        end
+      def _secret
+        Chef::Config[:knife][:cloudformation][:credentials][:secret] ||
+          Chef::Config[:knife][:aws_secret_access_key]
       end
 
-      def _format_json(thing)
-        thing = _from_json(thing) if thing.is_a?(String)
-        if(try_json_compat)
-          Chef::JSONCompat.to_json_pretty(thing)
-        else
-          JSON.pretty_generate(thing)
+      def _region
+        Chef::Config[:knife][:cloudformation][:credentials][:region] ||
+          Chef::Config[:knife][:region]
+      end
+
+    end
+
+    class << self
+      def included(klass)
+        klass.instance_eval do
+
+          extend KnifeCloudformation::KnifeBase::ClassMethods
+          include KnifeCloudformation::KnifeBase::InstanceMethods
+          include KnifeCloudformation::Utils::JSON
+          include KnifeCloudformation::Utils::AnimalStrings
+
+          deps do
+            require 'fog'
+            Chef::Config[:knife][:cloudformation] ||= Mash.new
+            Chef::Config[:knife][:cloudformation][:credentials] ||= Mash.new
+            Chef::Config[:knife][:cloudformation][:options] ||= Mash.new
+          end
+
+          option(:key,
+            :short => '-K KEY',
+            :long => '--key KEY',
+            :description => 'AWS access key id',
+            :proc => lambda {|val|
+              Chef::Config[:knife][:cloudformation][:credentials][:key] = val
+            }
+          )
+          option(:secret,
+            :short => '-S SECRET',
+            :long => '--secret SECRET',
+            :description => 'AWS secret access key',
+            :proc => lambda {|val|
+              Chef::Config[:knife][:cloudformation][:credentials][:secret] = val
+            }
+          )
+          option(:region,
+            :short => '-r REGION',
+            :long => '--region REGION',
+            :description => 'AWS region',
+            :proc => lambda {|val|
+              Chef::Config[:knife][:cloudformation][:credentials][:region] = val
+            }
+          )
+
+
+          # Populate up the hashes so they are available for knife config
+          # with issues of nils
+          ['knife.cloudformation.credentials', 'knife.cloudformation.options'].each do |stack|
+            stack.split('.').inject(Chef::Config) do |memo, item|
+              memo[item.to_sym] = Mash.new unless memo[item.to_sym]
+              memo[item.to_sym]
+            end
+          end
+
+          Chef::Config[:knife][:cloudformation] ||= Mash.new
+
         end
       end
     end
   end
+
 end

data/lib/chef/knife/cloudformation_create.rb

@@ -3,7 +3,9 @@ require 'chef/knife/cloudformation_base'
 
 class Chef
   class Knife
-    class CloudformationCreate < CloudformationBase
+    class CloudformationCreate < Knife
+
+      include KnifeCloudformation::KnifeBase
 
       banner 'knife cloudformation create NAME'
 
@@ -13,7 +15,7 @@ class Chef
             klass.class_eval do
 
               attr_accessor :action_type
-              
+
               option(:parameter,
                 :short => '-p KEY:VALUE',
                 :long => '--parameter KEY:VALUE',
@@ -32,11 +34,13 @@ class Chef
                   Chef::Config[:knife][:cloudformation][:options][:timeout_in_minutes] = val
                 }
               )
-              option(:disable_rollback,
+              option(:rollback,
                 :short => '-R',
-                :long => '--disable-rollback',
-                :description => 'Disable rollback on stack creation failure',
-                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:options][:disable_rollback] = true }
+                :long => '--[no]-rollback',
+                :description => 'Rollback on stack creation failure',
+                :boolean => true,
+                :default => true,
+                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:options][:disable_rollback] = !val }
               )
               option(:capability,
                 :short => '-C CAPABILITY',
@@ -47,15 +51,19 @@ class Chef
                   Chef::Config[:knife][:cloudformation][:options][:capabilities].push(val).uniq!
                 }
               )
-              option(:enable_processing,
-                :long => '--enable-processing',
-                :description => 'Call the unicorns.',
-                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:enable_processing] = true }
+              option(:processing,
+                :long => '--[no-]processing',
+                :description => 'Call the unicorns and explode the glitter bombs',
+                :boolean => true,
+                :default => false,
+                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:processing] = val }
               )
-              option(:disable_polling,
-                :long => '--disable-polling',
-                :description => 'Disable stack even polling.',
-                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:disable_polling] = true }
+              option(:polling,
+                :long => '--[no-]polling',
+                :description => 'Enable stack event polling.',
+                :boolean => true,
+                :default => true,
+                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:polling] = val }
               )
               option(:notifications,
                 :long => '--notification ARN',
@@ -73,23 +81,30 @@ class Chef
                   Chef::Config[:knife][:cloudformation][:file] = val
                 }
               )
-              option(:disable_interactive_parameters,
-                :long => '--no-parameter-prompts',
-                :description => 'Do not prompt for input on dynamic parameters'
+              option(:interactive_parameters,
+                :long => '--[no-]parameter-prompts',
+                :boolean => true,
+                :default => true,
+                :description => 'Do not prompt for input on dynamic parameters',
+                :default => true
               )
-
               option(:print_only,
                 :long => '--print-only',
                 :description => 'Print template and exit'
               )
+
+              %w(rollback polling interactive_parameters).each do |key|
+                if(Chef::Config[:knife][:cloudformation][key].nil?)
+                  Chef::Config[:knife][:cloudformation][key] = true
+                end
+              end
             end
           end
         end
       end
 
-      include CloudformationDefault
       include Options
-      
+
       def run
         @action_type = self.class.name.split('::').last.sub('Cloudformation', '').upcase
         unless(File.exists?(Chef::Config[:knife][:cloudformation][:file].to_s))
@@ -97,69 +112,46 @@ class Chef
           exit 1
         end
         name = name_args.first
-        if(Chef::Config[:knife][:cloudformation][:enable_processing])
+        if(Chef::Config[:knife][:cloudformation][:processing])
           file = KnifeCloudformation::SparkleFormation.compile(Chef::Config[:knife][:cloudformation][:file])
         else
           file = _from_json(File.read(Chef::Config[:knife][:cloudformation][:file]))
         end
-        ui.info "#{ui.color('Cloud Formation: ', :bold)} #{ui.color(action_type, :green)}"
-        ui.info "  -> #{ui.color('Name:', :bold)} #{name} #{ui.color('Path:', :bold)} #{Chef::Config[:knife][:cloudformation][:file]} #{ui.color('(not pre-processed)', :yellow) if Chef::Config[:knife][:cloudformation][:disable_processing]}"
-        stack = build_stack(file)
         if(config[:print_only])
           ui.warn 'Print only requested'
-          ui.info _format_json(stack['TemplateBody'])
+          ui.info _format_json(file)
           exit 1
         end
-        create_stack(name, stack)
-        unless(Chef::Config[:knife][:cloudformation][:disable_polling])
+        ui.info "#{ui.color('Cloud Formation: ', :bold)} #{ui.color(action_type, :green)}"
+        ui.info "  -> #{ui.color('Name:', :bold)} #{name} #{ui.color('Path:', :bold)} #{Chef::Config[:knife][:cloudformation][:file]} #{ui.color('(not pre-processed)', :yellow) if Chef::Config[:knife][:cloudformation][:disable_processing]}"
+        populate_parameters!(file)
+        stack_def = KnifeCloudformation::AwsCommons::Stack.build_stack_definition(file, Chef::Config[:knife][:cloudformation][:options])
+        aws.create_stack(name, stack_def)
+        if(Chef::Config[:knife][:cloudformation][:polling])
           poll_stack(name)
-        else
-          ui.warn 'Stack state polling has been disabled.'
-        end
-        ui.info "Stack #{action_type} complete: #{ui.color('SUCCESS', :green)}"
-      end
-
-      def build_stack(template)
-        stack = Mash.new
-        populate_parameters!(template)
-        Chef::Config[:knife][:cloudformation][:options].each do |key, value|
-          format_key = key.split('_').map(&:capitalize).join
-          stack[format_key] = value
-=begin          
-          case value
-          when Hash && key.to_sym != :parameters
-            i = 1
-            value.each do |k, v|
-              stack["#{format_key}.member.#{i}.#{format_key[0, (format_key.length - 1)]}Key"] = k
-              stack["#{format_key}.member.#{i}.#{format_key[0, (format_key.length - 1)]}Value"] = v
-            end
-          when Array
-            value.each_with_index do |v, i|
-              stack["#{format_key}.member.#{i+1}"] = v
-            end
+          if(stack(name).success?)
+            ui.info "Stack #{action_type} complete: #{ui.color('SUCCESS', :green)}"
+            knife_output = Chef::Knife::CloudformationDescribe.new
+            knife_output.name_args.push(name)
+            knife_output.config[:outputs] = true
+            knife_output.run
           else
-
+            ui.fatal "#{action_type} of new stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
+            ui.info ""
+            knife_inspect = Chef::Knife::CloudformationInspect.new
+            knife_inspect.name_args.push(name)
+            knife_inspect.config[:instance_failure] = true
+            knife_inspect.run
+            exit 1
           end
-=end
+        else
+          ui.warn 'Stack state polling has been disabled.'
+          ui.info "Stack creation initialized for #{ui.color(name, :green)}"
         end
-        enable_capabilities!(stack, template)
-        stack['TemplateBody'] = Chef::JSONCompat.to_json(template)
-        stack
       end
 
-      # Currently only checking for IAM resources since that's all
-      # that is supported for creation
-      def enable_capabilities!(stack, template)
-        found = Array(template['Resources']).detect do |resource_name, resource|
-          resource['Type'].start_with?('AWS::IAM')
-        end
-        if(found)
-          stack['Capabilities'] = ['CAPABILITY_IAM']
-        end
-      end
-      
       def populate_parameters!(stack)
-        unless(config[:disable_interactive_parameters])
+        if(Chef::Config[:knife][:cloudformation][:interactive_parameters])
           if(stack['Parameters'])
             Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
             stack['Parameters'].each do |k,v|
@@ -167,50 +159,21 @@ class Chef
               until(valid)
                 default = Chef::Config[:knife][:cloudformation][:options][:parameters][k] || v['Default']
                 answer = ui.ask_question("#{k.split(/([A-Z]+[^A-Z]*)/).find_all{|s|!s.empty?}.join(' ')} ", :default => default)
-                if(v['AllowedValues'])
-                  valid = v['AllowedValues'].include?(answer)
-                else
-                  valid = true
-                end
-                if(valid)
+                validation = KnifeCloudformation::AwsCommons::Stack::ParameterValidator.validate(answer, v)
+                if(validation == true)
                   Chef::Config[:knife][:cloudformation][:options][:parameters][k] = answer
+                  valid = true
                 else
-                  ui.error "Not an allowed value: #{v['AllowedValues'].join(', ')}"
+                  validation.each do |validation_error|
+                    ui.error validation_error.last
+                  end
                 end
               end
             end
           end
         end
       end
-      
-      def create_stack(name, stack)
-        begin
-          res = aws_con.create_stack(name, stack)
-        rescue => e
-          ui.fatal "Failed to #{action_type} stack #{name}. Reason: #{e}"
-          _debug(e, "Generated template used:\n#{_format_json(stack['TemplateBody'])}")
-          exit 1
-        end
-      end
 
-      def poll_stack(name)
-        knife_events = Chef::Knife::CloudformationEvents.new
-        knife_events.name_args.push(name)
-        Chef::Config[:knife][:cloudformation][:poll] = true
-        knife_events.run
-        unless(action_successful?(name))
-          ui.fatal "#{action_type} of new stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
-          exit 1
-        end
-      end
-      
-      def action_in_progress?(name)
-        stack_status(name) == 'CREATE_IN_PROGRESS'
-      end
-
-      def action_successful?(name)
-        stack_status(name) == 'CREATE_COMPLETE'
-      end
     end
   end
 end