knife-cloudformation 0.1.22 → 0.2.0

data/lib/chef/knife/cloudformation_import.rb

@@ -1,35 +1,141 @@
-require 'knife-cloudformation/cloudformation_base'
+require 'stringio'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation import command
     class CloudformationImport < Knife
 
-      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Knife::Base
+      include KnifeCloudformation::Utils::JSON
+      include KnifeCloudformation::Utils::ObjectStorage
+      include KnifeCloudformation::Utils::PathSelector
 
-      banner 'knife cloudformation import NEW_STACK_NAME JSON_EXPORT_FILE'
+      banner 'knife cloudformation import NEW_STACK_NAME [JSON_EXPORT_FILE]'
 
-      def run
+      option(:path,
+        :long => '--import-path PATH',
+        :description => 'Directory path JSON export files are located',
+        :proc => lambda{|v|
+          Chef::Config[:knife][:cloudformation][:import][:path] = File.expand_path(v)
+        }
+      )
+
+      option(:bucket,
+        :long => '--export-bucket BUCKET_NAME',
+        :description => 'Remote file bucket JSON export files are located',
+        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:import][:bucket] = v}
+      )
+
+      option(:bucket_prefix,
+        :long => '--bucket-key-prefix PREFIX',
+        :description => 'Key prefix for file storage in bucket. Can be callable block if defined within configuration',
+        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:import][:bucket_prefix] = v}
+      )
+
+      unless(Chef::Config[:knife][:cloudformation].has_key?(:import))
+        Chef::Config[:knife][:cloudformation][:import] = Mash.new
+      end
+
+      # Run the import action
+      def _run
         stack_name, json_file = name_args
-        ui.info "#{ui.color('Stack Import', :bold)} (#{json_file})"
-        if(File.exists?(json_file))
-          stack = _from_json(File.read(json_file))
-          creator = Chef::Knife::CloudformationCreate.new
-          creator.name_args = [stack_name]
-          Chef::Config[:knife][:cloudformation][:template] = stack['template_body']
-          Chef::Config[:knife][:cloudformation][:options] = Mash.new
-          Chef::Config[:knife][:cloudformation][:options][:parameters] = Mash.new
-          stack['parameters'].each do |k,v|
-            Chef::Config[:knife][:cloudformation][:options][:parameters][k] = v
+        ui.info "#{ui.color('Stack Import:', :bold)} #{stack_name}"
+        unless(json_file)
+          entries = [].tap do |_entries|
+            _entries.push('s3') if Chef::Config[:knife][:cloudformation][:import][:bucket]
+            _entries.push('fs') if Chef::Config[:knife][:cloudformation][:import][:path]
+          end
+          if(entries.size > 1)
+            valid = false
+            until(valid)
+              answer = ui.ask_question('Import via file system (fs) or remote bucket (remote)?', :default => 'remote')
+              valid = true if %w(remote fs).include?(answer)
+              entries = [answer]
+            end
+          elsif(entries.size < 1)
+            ui.fatal 'No path or bucket set. Unable to perform dynamic lookup!'
+            exit 1
+          end
+          case entries.first
+          when 'remote'
+            json_file = remote_discovery
+          else
+            json_file = local_discovery
+          end
+        end
+        if(File.exists?(json_file) || json_file.is_a?(IO))
+          content = json_file.is_a?(IO) ? json_file.read : File.read(json_file)
+          export = Mash.new(_from_json(content))
+          begin
+            creator = Chef::Knife::CloudformationCreate.new
+            creator.name_args = [stack_name]
+            Chef::Config[:knife][:cloudformation][:template] = _from_json(export[:stack][:template])
+            Chef::Config[:knife][:cloudformation][:options] = export[:stack][:options]
+            ui.info '  - Starting creation of import'
+            creator.run
+            ui.info "#{ui.color('Stack Import', :bold)} (#{json_file}): #{ui.color('complete', :green)}"
+          rescue => e
+            ui.fatal "Failed to import stack: #{e}"
+            debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+            exit -1
           end
-          ui.info '  - Starting creation of import'
-          creator.run
-          ui.info "#{ui.color('Stack Import', :bold)} (#{json_file}): #{ui.color('complete', :green)}"
         else
-          ui.error "Failed to locate JSON export file (#{json_file})"
+          ui.fatal "Failed to locate JSON export file (#{json_file})"
           exit 1
         end
       end
 
+      # Generate bucket prefix
+      #
+      # @return [String, NilClass]
+      def bucket_prefix
+        if(prefix = Chef::Config[:knife][:cloudformation][:import][:bucket_prefix])
+          if(prefix.respond_to?(:cal))
+            prefix.call
+          else
+            prefix.to_s
+          end
+        end
+      end
+
+      # Discover remote file
+      #
+      # @return [IO] stack export IO
+      def remote_discovery
+        storage = provider.service_for(:storage)
+        directory = storage.directories.get(
+          Chef::Config[:knife][:cloudformation][:import][:bucket]
+        )
+        file = prompt_for_file(
+          directory,
+          :directories_name => 'Collections',
+          :files_names => 'Exports',
+          :filter_prefix => bucket_prefix
+        )
+        if(file)
+          remote_file = storage.files.get(file)
+          StringIO.new(remote_file.body)
+        end
+      end
+
+      # Discover remote file
+      #
+      # @return [IO] stack export IO
+      def local_discovery
+        _, bucket = Chef::Config[:knife][:cloudformation][:import][:path].split('/', 2)
+        storage = provider.service_for(:storage,
+          :provider => :local,
+          :local_root => '/'
+        )
+        directory = storage.directories.get(bucket)
+        prompt_for_file(
+          directory,
+          :directories_name => 'Collections',
+          :files_names => 'Exports'
+        )
+      end
+
     end
   end
 end

data/lib/chef/knife/cloudformation_inspect.rb

@@ -1,111 +1,133 @@
-require 'knife-cloudformation/cloudformation_base'
-require 'knife-cloudformation/utils'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation inspect command
     class CloudformationInspect < Knife
 
-      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Knife::Base
       include KnifeCloudformation::Utils::Ssher
 
       banner 'knife cloudformation inspect NAME'
 
-      option(:instance_failure,
-        :short => '-I',
-        :long => '--instance-failure',
+      option(:attribute,
+        :short => '-a ATTR',
+        :long => '--attribute ATTR',
+        :description => 'Dot delimited attribute to view'
+      )
+
+      option(:nodes,
+        :short => '-N',
+        :long => '--[no-]nodes',
         :boolean => true,
-        :description => 'Display log from failed instance'
+        :description => 'Locate all instances'
+      )
+
+      option(:instance_failure,
+        :short => '-I [LOG_FILE_PATH]',
+        :long => '--instance-failure [LOG_FILE_PATH]',
+        :descrption => 'Display chef log file (defaults /var/log/chef/client.log)',
+        :proc => lambda{|val|
+          Chef::Config[:knife][:cloudformation][:failure_log_path] = val
+        }
       )
 
       option(:identity_file,
         :short => '-i IDENTITY_FILE',
         :long => '--identity-file IDENTITY_FILE',
-        :description => 'The SSH identity file used for authentication',
-        :proc => lambda {|val|
+        :description => 'SSH identity file for authentication',
+        :proc => lambda{|val|
           Chef::Config[:knife][:cloudformation][:identity_file] = val
         }
       )
 
-      option(:nodes,
-        :short => '-N',
-        :long => '--nodes',
-        :boolean => true,
-        :description => 'Display ec2 nodes of stack'
-      )
-
       option(:ssh_user,
         :short => '-x SSH_USER',
         :long => '--ssh-user SSH_USER',
-        :description => 'The ssh username',
-        :proc => lambda {|val|
+        :description => 'SSH username for inspection connect',
+        :proc => lambda{|val|
           Chef::Config[:knife][:cloudformation][:ssh_user] = val
         }
       )
 
-      def run
+      # Run the stack inspection action
+      def _run
         stack_name = name_args.last
-        if(config[:instance_failure])
-          do_instance_failure(stack_name)
-        end
-        if(config[:nodes])
-          do_node_list(stack_name)
-        end
-      end
-
-      def do_node_list(stack_name)
-        nodes = stack(stack_name).nodes.map do |n|
-          [n.id, n.public_ip_address]
-        end.flatten
-        ui.info "Nodes for stack: #{ui.color(stack_name, :bold)}"
-        ui.info "#{ui.list(nodes, :uneven_columns_across, 2)}"
-      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
+        stack = provider.stacks.get(stack_name)
+        ui.info "Stack inspection #{ui.color(stack_name, :bold)}:"
+        outputs = [:attribute, :nodes, :instance_failure].map do |key|
+          if(config.has_key?(key))
+            send("display_#{key}", stack)
+            key
+          end
+        end.compact
+        if(outputs.empty?)
+          ui.info '  Stack dump:'
+          ui.info MultiJson.dump(
+            MultiJson.load(
+              stack.reload.to_json
+            ),
+            :pretty => true
+          )
         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 = nil
-        attempt_ssh_users.each do |ssh_user_name|
-          begin
-            content = remote_file_contents(inst_addr, ssh_user_name, remote_path, opts)
-            break
-          rescue Net::SSH::AuthenticationFailed
-            ui.warn "Authentication failed for user: #{ssh_user_name} on instance: #{inst_addr}"
+      def display_instance_failure(stack)
+        instances = stack.resources.all.find_all do |resource|
+          resource.state.to_s.end_with?('failed')
+        end.map do |resource|
+          # If compute instance, simply expand
+          if(resource.within?(:compute, :servers))
+            resource.instance
+          # If a waitcondition, check for instance ID
+          elsif(resource.type.to_s.downcase.end_with?('waitcondition'))
+            if(resource.status_reason.to_s.include?('uniqueId'))
+              srv_id = resource.status_reason.split(' ').last.strip
+              provider.connection.api_for(:compute).servers.get(srv_id)
+            end
           end
-        end
-        if(content)
-          ui.info "  content of #{remote_path}:"
-          ui.info ""
-          ui.info content
+        end.compact
+        if(instances.empty?)
+          ui.error 'Failed to locate any failed instances'
         else
-          ui.error "Failed to retreive content from node at: #{inst_addr}"
+          log_path = Chef::Config[:knife][:cloudformation][:failure_log_path]
+          if(log_path.to_s.empty?)
+            log_path = '/var/log/chef/client.log'
+          end
+          opts = ssh_key ? {:keys => [ssh_key]} : {}
+          instances.each do |instance|
+            ui.info "  -> Log inspect for #{instance.id}:"
+            address = instance.addresses_public.map do |address|
+              if(address.version == 4)
+                address.address
+              end
+            end
+            if(address)
+              ssh_attempt_users.each do |user|
+                begin
+                  ui.info remote_file_contents(address.first, user, log_path, opts)
+                  break
+                rescue Net::SSH::AuthenticationFailed
+                  ui.warn "Authentication failed for user #{user} on instance #{address}"
+                rescue => e
+                  ui.error "Failed to retrieve log: #{e}"
+                  _debug e
+                  break
+                end
+              end
+            end
+          end
         end
       end
 
-      def attempt_ssh_users
-        ([ssh_user] + Array(Chef::Config[:knife][:cloudformation][:ssh_attempt_users])).flatten.compact
-      end
-
-      def ssh_user
-        Chef::Config[:knife][:cloudformation][:ssh_user] ||
+      # Users to attempt SSH connection
+      #
+      # @return [Array<String>] usernames for ssh connect attempt
+      def ssh_attempt_users
+        base_user = Chef::Config[:knife][:cloudformation][:ssh_user] ||
           Chef::Config[:knife][:ssh_user] ||
           ENV['USER']
+        [base_user, Chef::Config[:knife][:cloudformation][:ssh_attempt_users]].flatten.compact
       end
 
       def ssh_key
@@ -113,6 +135,72 @@ class Chef
           Chef::Config[:knife][:identity_file]
       end
 
+      def display_attribute(stack)
+        attr = config[:attribute].split('.').inject(stack) do |memo, key|
+          args = key.scan(/\(([^)]*)\)/).flatten.first.to_s
+          if(args)
+            args = args.split(',').map{|a| a.to_i.to_s == a ? a.to_i : a}
+            key = key.split('(').first
+          end
+          if(memo.public_methods.include?(key.to_sym))
+            if(args.size == 1 && args.first.to_s.start_with?('&'))
+              memo.send(key, &args.first.slice(2, args.first.size).to_sym)
+            else
+              memo.send(*[key, args].flatten.compact)
+            end
+          else
+            raise NoMethodError.new "Invalid attribute requested! (#{memo.class}##{key})"
+          end
+        end
+        ui.info "  Attribute Lookup -> #{config[:attribute]}:"
+        ui.info MultiJson.dump(
+          MultiJson.load(
+            MultiJson.dump(attr)
+          ),
+          :pretty => true
+        )
+      end
+
+      def display_nodes(stack)
+        asg_nodes = Smash[
+          stack.resources.all.find_all do |resource|
+            resource.within?(:auto_scale, :groups)
+          end.map do |group_resource|
+            asg = group_resource.expand
+            [
+              asg.name,
+              Smash[
+                asg.servers.map(&:expand).map{|s|
+                  [s.id, Smash.new(
+                      :name => s.name,
+                      :addresses => s.addresses.map(&:address)
+                  )]
+                }
+              ]
+            ]
+          end
+        ]
+        compute_nodes = Smash[
+          stack.resources.all.find_all do |resource|
+            resource.within?(:compute, :servers)
+          end.map do |srv|
+            srv = srv.instance
+            [srv.id, Smash.new(
+                :name => srv.name,
+                :addresses => srv.addresses.map(&:address)
+            )]
+          end
+        ]
+        unless(asg_nodes.empty?)
+          ui.info '  AutoScale Group Instances:'
+          ui.info MultiJson.dump(asg_nodes, :pretty => true)
+        end
+        unless(compute_nodes.empty?)
+          ui.info '  Compute Instances:'
+          ui.info MultiJson.dump(compute_nodes, :pretty => true)
+        end
+      end
+
     end
   end
 end

data/lib/chef/knife/cloudformation_list.rb

@@ -1,9 +1,11 @@
-require 'knife-cloudformation/cloudformation_base'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation list command
     class CloudformationList < Knife
-      include KnifeCloudformation::KnifeBase
+
+      include KnifeCloudformation::Knife::Base
 
       banner 'knife cloudformation list NAME'
 
@@ -32,43 +34,37 @@ class Chef
         }
       )
 
-      def run
+      # Run the list command
+      def _run
         things_output(nil, get_list, nil)
       end
 
+      # Get the list of stacks to display
+      #
+      # @return [Array<Hash>]
       def get_list
         get_things do
-          aws.aws(:cloud_formation).list_stacks(list_options).body['StackSummaries'].sort do |x,y|
-            if(y['CreationTime'].to_s.empty?)
+          provider.stacks.all.map do |stack|
+            Mash.new(stack.attributes)
+          end.sort do |x, y|
+            if(y[:created].to_s.empty?)
               -1
-            elsif(x['CreationTime'].to_s.empty?)
+            elsif(x[:created].to_s.empty?)
               1
             else
-              Time.parse(y['CreationTime'].to_s) <=> Time.parse(x['CreationTime'].to_s)
+              Time.parse(y['created'].to_s) <=> Time.parse(x['created'].to_s)
             end
           end
         end
       end
 
-      def list_options
-        status = Chef::Config[:knife][:cloudformation][:status] ||
-          KnifeCloudformation::AwsCommons::DEFAULT_STACK_STATUS
-        if(status.map(&:downcase).include?('none'))
-          filter = {}
+      # @return [Array<String>] default attributes to display
+      def default_attributes
+        if(provider.connection.provider == :aws)
+          %w(name created status template_description)
         else
-          count = 0
-          filter = Hash[*(
-              status.map do |n|
-                count += 1
-                ["StackStatusFilter.member.#{count}", n]
-              end.flatten
-          )]
+          %w(name created status description)
         end
-        filter
-      end
-
-      def default_attributes
-        %w(StackName CreationTime StackStatus TemplateDescription)
       end
 
     end