knife-cloudformation 0.1.2 → 0.1.4

data/lib/chef/knife/cloudformation_describe.rb

@@ -2,17 +2,24 @@ require 'chef/knife/cloudformation_base'
 
 class Chef
   class Knife
-    class CloudformationDescribe < CloudformationBase
-      include CloudformationDefault
+    class CloudformationDescribe < Knife
+
+      include KnifeCloudformation::KnifeBase
 
       banner 'knife cloudformation describe NAME'
-      
+
       option(:resources,
         :short => '-r',
         :long => '--resources',
-        :description => 'Display resources for stack(s)'
+        :description => 'Display resources for stack'
+      )
+
+      option(:outputs,
+        :short => '-o',
+        :long => '--outputs',
+        :description => 'Display output for stack'
       )
-      
+
       option(:attribute,
         :short => '-a ATTR',
         :long => '--attribute ATTR',
@@ -27,11 +34,22 @@ class Chef
         :long => '--all-attributes',
         :description => 'Print all attributes'
       )
-      
+
       def run
-        name_args.each do |stack|
-          things_output(stack,
-            *(config[:resources] ? [get_resources(stack), :resources] : [get_description(stack), :description])
+        stack_name = name_args.last
+        if(config[:outputs])
+          ui.info "Outputs for stack: #{ui.color(stack_name, :bold)}:"
+          unless(stack(stack_name).outputs.empty?)
+            stack(stack_name).outputs.each do |key, value|
+              key = snake(key).to_s.split('_').map(&:capitalize).join(' ')
+              ui.info ['  ', ui.color("#{key}:", :bold), value].join(' ')
+            end
+          else
+            ui.info "  #{ui.color('No outputs found')}"
+          end
+        else
+          things_output(stack_name,
+            *(config[:resources] ? [get_resources(stack_name), :resources] : [get_description(stack_name), :description])
           )
         end
       end
@@ -40,18 +58,18 @@ class Chef
         config[:resources] ? %w(Timestamp ResourceType ResourceStatus) : %w(StackName CreationTime StackStatus DisableRollback)
       end
 
-      def get_description(stack)
-        get_things(stack) do
-          [aws_con.describe_stacks('StackName' => stack).body['Stacks'].first]
+      def get_description(name)
+        get_things(name) do
+          [stack(name).raw_stack]
         end
       end
-      
-      def get_resources(stack)
-        get_things(stack) do
-          aws_con.describe_stack_resources('StackName' => stack).body['StackResources']
+
+      def get_resources(name)
+        get_things(name) do
+          stack(name).resources
         end
       end
-      
+
     end
   end
 end

data/lib/chef/knife/cloudformation_destroy.rb

@@ -2,27 +2,27 @@ require 'chef/knife/cloudformation_base'
 
 class Chef
   class Knife
-    class CloudformationDestroy < CloudformationBase
+    class CloudformationDestroy < Knife
 
-      include CloudformationDefault
-      
-      banner 'knife cloudformation destroy NAME[ NAME ...]'
+      include KnifeCloudformation::KnifeBase
+
+      banner 'knife cloudformation destroy NAME'
 
       def run
-        name_args.each do |stack_name|
-          ui.warn "Destroying Cloud Formation: #{ui.color(stack_name, :bold)}"
-          ui.confirm 'Destroy this formation'
-          destroy_formation!(stack_name)
-          ui.info "  -> Destroyed Cloud Formation: #{ui.color(stack_name, :bold, :red)}"
-        end
+        stack_name = name_args.last
+        ui.warn "Destroying Cloud Formation: #{ui.color(stack_name, :bold)}"
+        ui.confirm 'Destroy this formation'
+        destroy_formation!(stack_name)
+        poll_stack(stack_name)
+        ui.info "  -> Destroyed Cloud Formation: #{ui.color(stack_name, :bold, :red)}"
       end
 
       def destroy_formation!(stack_name)
         get_things(stack_name, 'Failed to perform destruction') do
-          aws_con.delete_stack(stack_name)
+          stack(stack_name).destroy
         end
       end
-      
+
     end
   end
 end

data/lib/chef/knife/cloudformation_events.rb

@@ -2,17 +2,17 @@ require 'chef/knife/cloudformation_base'
 
 class Chef
   class Knife
-    class CloudformationEvents < CloudformationBase
+    class CloudformationEvents < Knife
 
       banner 'knife cloudformation events NAME'
 
-      include CloudformationDefault
-      
-      option(:poll,
+      include KnifeCloudformation::KnifeBase
+
+      option(:polling,
         :short => '-p',
-        :long => '--poll',
+        :long => '--[no-]poll',
         :description => 'Poll events while stack status is "in progress"',
-        :proc => lambda {|v| Chef::Config[:knife][:cloudformation][:poll] = true }
+        :proc => lambda {|v| Chef::Config[:knife][:cloudformation][:polling] = v }
       )
 
       option(:attribute,
@@ -25,6 +25,15 @@ class Chef
         }
       )
 
+      option(:poll_delay,
+        :short => '-D secs',
+        :long => '--poll-delay secs',
+        :description => 'Number of seconds to pause between event poll',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:poll_delay] = val.to_i
+        }
+      )
+
       option(:all_attributes,
         :long => '--all-attributes',
         :description => 'Print all attributes'
@@ -33,50 +42,23 @@ class Chef
       def run
         name = name_args.first
         ui.info "Cloud Formation Events for Stack: #{ui.color(name, :bold)}\n"
-        events = stack_events(name)
-        output = get_titles(events, :format)
-        output += process(events)
-        ui.info ui.list(output.flatten, :uneven_columns_across, allowed_attributes.size)
+        things_output(name, get_events(name), 'events')
         if(Chef::Config[:knife][:cloudformation][:poll])
-          poll_stack(name)
-        end
-      end
-      
-      def stack_events(name, continue_from_last=true)
-        get_things(name) do
-          @_stack_events ||= Mash.new
-          if(@_stack_events[name])
-            options = {'NextToken' => @_stack_events[name]}
-          else
-            options = {}
+          while(stack(name).in_progress?)
+            sleep(Chef::Config[:knife][:cloudformation][:poll_delay] || 15)
+            things_output(nil, get_events(name), 'events', :no_title, :ignore_empty_output)
           end
-          res = aws_con.describe_stack_events(name, options)
-          @_stack_events[name] = res.body['StackToken']
-          res.body['StackEvents']
+          # Extra to see completion
+          things_output(nil, get_events(name), 'events', :no_title, :ignore_empty_output)
         end
       end
 
-      def poll_stack(name)
-        while(stack_in_progress?(name))
-          events = stack_events(name)
-          output = process(events)
-          unless(output.empty?)
-            ui.info ui.list(output, :uneven_columns_across, allowed_attributes.size)
-          end
-          sleep((ENV['CLOUDFORMATION_POLL'] || 15).to_i)
-        end
-        # One more to see completion
-        events = stack_events(name)
-        output = process(events)
-        unless(output.empty?)
-          ui.info ui.list(output, :uneven_columns_across, allowed_attributes.size)
+      def get_events(name)
+        get_things do
+          stack(name).events
         end
       end
 
-      def stack_in_progress?(name)
-        stack_status(name).downcase.include?('in_progress')
-      end
-
       def default_attributes
         %w(Timestamp LogicalResourceId ResourceType ResourceStatus ResourceStatusReason)
       end

data/lib/chef/knife/cloudformation_inspect.rb

@@ -0,0 +1,84 @@
+require 'chef/knife/cloudformation_base'
+require 'knife-cloudformation/utils'
+
+class Chef
+  class Knife
+    class CloudformationInspect < Knife
+
+      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Utils::Ssher
+
+      banner 'knife cloudformation inspect NAME'
+
+      option(:instance_failure,
+        :short => '-I',
+        :long => '--instance-failure',
+        :boolean => true,
+        :description => 'Display log from failed instance'
+      )
+
+      option(:identity_file,
+        :short => '-i IDENTITY_FILE',
+        :long => '--identity-file IDENTITY_FILE',
+        :description => 'The SSH identity file used for authentication',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:identity_file] = val
+        }
+      )
+
+      option(:ssh_user,
+        :short => '-x SSH_USER',
+        :long => '--ssh-user SSH_USER',
+        :description => 'The ssh username',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:ssh_user] = val
+        }
+      )
+
+      def run
+        stack_name = name_args.last
+        if(config[:instance_failure])
+          do_instance_failure(stack_name)
+        end
+      end
+
+      def do_instance_failure(stack_name)
+        event = stack(stack_name).events.detect do |e|
+          e['ResourceType'] == 'AWS::CloudFormation::WaitCondition' &&
+            e['ResourceStatus'] == 'CREATE_FAILED' &&
+            e['ResourceStatusReason'].include?('uniqueId')
+        end
+        if(event)
+          process_instance_failure(stack_name, event)
+        else
+          ui.error "Failed to discover failed node within stack: #{stack_name}"
+          exit 1
+        end
+      end
+
+      def process_instance_failure(stack_name, event)
+        inst_id = event['ResourceStatusReason'].split(' ').last.strip
+        inst_addr = aws.aws(:ec2).servers.get(inst_id).public_ip_address
+        ui.info "Displaying stack #{ui.color(stack_name, :bold)} failure on instance #{ui.color(inst_id, :bold)}"
+        opts = ssh_key ? {:keys => [ssh_key]} : {}
+        remote_path = '/var/log/cfn-init.log'
+        content = remote_file_contents(inst_addr, ssh_user, remote_path, opts)
+        ui.info "  content of #{remote_path}:"
+        ui.info ""
+        ui.info content
+      end
+
+      def ssh_user
+        Chef::Config[:knife][:cloudformation][:ssh_user] ||
+          Chef::Config[:knife][:ssh_user] ||
+          ENV['USER']
+      end
+
+      def ssh_key
+        Chef::Config[:knife][:cloudformation][:identity_file] ||
+          Chef::Config[:knife][:identity_file]
+      end
+
+    end
+  end
+end

data/lib/chef/knife/cloudformation_list.rb

@@ -2,11 +2,11 @@ require 'chef/knife/cloudformation_base'
 
 class Chef
   class Knife
-    class CloudformationList < CloudformationBase
-      include CloudformationDefault
+    class CloudformationList < Knife
+      include KnifeCloudformation::KnifeBase
 
       banner 'knife cloudformation list NAME'
-      
+
       option(:attribute,
         :short => '-a ATTR',
         :long => '--attribute ATTR',
@@ -31,14 +31,14 @@ class Chef
           Chef::Config[:knife][:cloudformation][:status].push(val).uniq!
         }
       )
-      
+
       def run
         things_output(nil, get_list, nil)
       end
 
       def get_list
         get_things do
-          aws_con.list_stacks(aws_filter_hash).body['StackSummaries']
+          aws.stacks
         end
       end
 
@@ -46,18 +46,6 @@ class Chef
         %w(StackName CreationTime StackStatus TemplateDescription)
       end
 
-      def status_filter
-        val = Chef::Config[:knife][:cloudformation][:status] || %w(CREATE_COMPLETE CREATE_IN_PROGRESS UPDATE_IN_PROGRESS UPDATE_COMPLETE_CLEANUP_IN_PROGRESS UPDATE_COMPLETE)
-        val.map(&:downcase).include?('none') ? [] : val.map(&:upcase)
-      end
-
-      def aws_filter_hash
-        hash = Mash.new
-        status_filter.each_with_index do |filter, i|
-          hash["StackStatusFilter.member.#{i+1}"] = filter
-        end
-        hash
-      end
     end
   end
 end

data/lib/chef/knife/cloudformation_update.rb

@@ -2,12 +2,12 @@ require 'chef/knife/cloudformation_create'
 
 class Chef
   class Knife
-    class CloudformationUpdate < CloudformationCreate
+    class CloudformationUpdate < Knife
       banner 'knife cloudformation update NAME'
 
-      include CloudformationDefault
+      include KnifeCloudformation::KnifeBase
       include CloudformationCreate::Options
-      
+
       def create_stack(name, stack)
         begin
           res = aws_con.update_stack(name, stack)

data/lib/knife-cloudformation/aws_commons.rb

@@ -0,0 +1,118 @@
+require 'fog'
+require 'knife-cloudformation/utils'
+
+Dir.glob(File.join(File.dirname(__FILE__), 'aws_commons/*.rb')).each do |item|
+  require "knife-cloudformation/aws_commons/#{File.basename(item).sub('.rb', '')}"
+end
+
+module KnifeCloudformation
+  class AwsCommons
+
+    FOG_MAP = {
+      :ec2 => :compute
+    }
+
+    def initialize(args={})
+      @ui = args[:ui]
+      @creds = args[:fog]
+      @connections = {}
+      @memo = {
+        :stacks => {},
+        :event_ids => [],
+        :stack_list => {}
+      }
+    end
+
+    def build_connection(type)
+      type = type.to_sym
+      type = FOG_MAP[type] if FOG_MAP[type]
+      unless(@connections[type])
+        if(type == :compute)
+          @connections[:compute] = Fog::Compute::AWS.new(@creds)
+        else
+          Fog.credentials = Fog.symbolize_credentials(@creds)
+          @connections[type] = Fog::AWS[type]
+          Fog.credentials = {}
+        end
+      end
+      @connections[type]
+    end
+    alias_method :aws, :build_connection
+
+    DEFAULT_STACK_STATUS = %w(
+      CREATE_IN_PROGRESS CREATE_COMPLETE CREATE_FAILED
+      ROLLBACK_IN_PROGRESS ROLLBACK_COMPLETE ROLLBACK_FAILED
+      UPDATE_IN_PROGRESS UPDATE_COMPLETE UPDATE_COMPLETE_CLEANUP_IN_PROGRESS
+      UPDATE_ROLLBACK_IN_PROGRESS UPDATE_ROLLBACK_FAILED
+      UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS UPDATE_ROLLBACK_COMPLETE
+      DELETE_IN_PROGRESS DELETE_FAILED
+    )
+
+    def stacks(args={})
+      status = args[:status] || DEFAULT_STACK_STATUS
+      key = status.hash
+      @memo[:stack_list].delete(key) if args[:force_refresh]
+      count = 0
+      if(status.map(&:downcase).include?('none'))
+        filter = {}
+      else
+        filter = Hash[*(
+            status.map do |n|
+              count += 1
+              ["StackStatusFilter.member.#{count}", n]
+            end.flatten
+        )]
+      end
+      unless(@memo[:stack_list][key])
+        @memo[:stack_list][key] = aws(:cloud_formation).list_stacks(filter).body['StackSummaries']
+      end
+      @memo[:stack_list][key]
+    end
+
+    def stack(name)
+      unless(@memo[:stacks][name])
+        @memo[:stacks][name] = Stack.new(name, self)
+      end
+      @memo[:stacks][name]
+    end
+
+    def create_stack(name, definition)
+      Stack.create(name, definition, self)
+    end
+
+    # Output Helpers
+
+    def process(things, args={})
+      @event_ids ||= []
+      processed = things.reverse.map do |thing|
+        next if @memo[:event_ids].include?(thing['EventId'])
+        @event_ids.push(thing['EventId']).compact!
+        if(args[:attributes])
+          args[:attributes].map do |key|
+            thing[key].to_s
+          end
+        else
+          thing.values
+        end
+      end
+      args[:flat] ? processed.flatten : processed
+    end
+
+    def get_titles(thing, args={})
+      attrs = args[:attributes] || []
+      if(attrs.empty?)
+        hash = thing.is_a?(Array) ? thing.first : thing
+        hash ||= {}
+        attrs = hash.keys
+      end
+      titles = attrs.map do |key|
+        key.gsub(/([a-z])([A-Z])/, '\1 \2')
+      end.compact
+      if(args[:format])
+        titles.map{|s| @ui.color(s, :bold)}
+      else
+        titles
+      end
+    end
+  end
+end