knife-ec2 0.5.6 → 0.5.8

data/.gitignore

@@ -0,0 +1,34 @@
+.rake_tasks~
+tags
+coverage
+rdoc
+pkg
+test/tmp
+test/version_tmp
+tmp
+pkg
+*.gem
+*.rbc
+lib/bundler/man
+spec/reports
+.config
+InstalledFiles
+.bundle
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.DS_Store
+Icon?
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+*.swp
+*.swo

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-fs

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in knife-rackspace.gemspec
+gemspec

data/README.rdoc

@@ -6,6 +6,10 @@ This is the official Opscode Knife plugin for EC2. This plugin gives knife the a
 
 = INSTALLATION:
 
+Be sure you are running the latest version Chef. Versions earlier than 0.10.0 don't support plugins:
+
+    gem install chef
+
 This plugin is distributed as a Ruby Gem. To install it, run:
 
     gem install knife-ec2

data/Rakefile

@@ -0,0 +1,56 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# require 'rubygems'
+# require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+begin
+  require 'sdoc'
+
+  Rake::RDocTask.new do |rdoc|
+    rdoc.title = "Chef Ruby API Documentation"
+    rdoc.main = "README.rdoc"
+    rdoc.options << '--fmt' << 'shtml' # explictly set shtml generator
+    rdoc.template = 'direct' # lighter template
+    rdoc.rdoc_files.include("README.rdoc", "LICENSE", "spec/tiny_server.rb", "lib/**/*.rb")
+    rdoc.rdoc_dir = "rdoc"
+  end
+rescue LoadError
+  puts "sdoc is not available. (sudo) gem install sdoc to generate rdoc documentation."
+end
+
+begin
+  require 'rspec/core/rake_task'
+
+  task :default => :spec
+
+  desc "Run all specs in spec directory"
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = 'spec/unit/**/*_spec.rb'
+  end
+
+rescue LoadError
+  STDERR.puts "\n*** RSpec not available. (sudo) gem install rspec to run unit tests. ***\n\n"
+end
+

data/knife-ec2.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "knife-ec2/version"
+
+Gem::Specification.new do |s|
+  s.name        = "knife-ec2"
+  s.version     = Knife::Ec2::VERSION
+  s.has_rdoc = true
+  s.authors     = ["Adam Jacob","Seth Chisamore"]
+  s.email       = ["adam@opscode.com","schisamo@opscode.com"]
+  s.homepage = "http://wiki.opscode.com/display/chef"
+  s.summary = "Rackspace Support for Chef's Knife Command"
+  s.description = s.summary
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE" ]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.add_dependency "fog", "~> 0.8.2"
+  s.require_paths = ["lib"]
+
+end

data/lib/chef/knife/ec2_base.rb

@@ -0,0 +1,98 @@
+#
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module Ec2Base
+
+      # :nodoc:
+      # Would prefer to do this in a rational way, but can't be done b/c of
+      # Mixlib::CLI's design :(
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'fog'
+            require 'readline'
+            require 'chef/json_compat'
+          end
+
+          option :aws_access_key_id,
+            :short => "-A ID",
+            :long => "--aws-access-key-id KEY",
+            :description => "Your AWS Access Key ID",
+            :proc => Proc.new { |key| Chef::Config[:knife][:aws_access_key_id] = key }
+
+          option :aws_secret_access_key,
+            :short => "-K SECRET",
+            :long => "--aws-secret-access-key SECRET",
+            :description => "Your AWS API Secret Access Key",
+            :proc => Proc.new { |key| Chef::Config[:knife][:aws_secret_access_key] = key }
+
+          option :region,
+            :long => "--region REGION",
+            :description => "Your AWS region",
+            :default => "us-east-1",
+            :proc => Proc.new { |key| Chef::Config[:knife][:region] = key }
+        end
+      end
+
+      def connection
+        @connection ||= begin
+          connection = Fog::Compute.new(
+            :provider => 'AWS',
+            :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
+            :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
+            :region => locate_config_value(:region)
+          )
+        end
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        Chef::Config[:knife][key] || config[key]
+      end
+
+      def msg_pair(label, value, color=:cyan)
+        if value && !value.empty?
+          puts "#{ui.color(label, color)}: #{value}"
+        end
+      end
+
+      def validate!(keys=[:aws_access_key_id, :aws_secret_access_key])
+        errors = []
+
+        keys.each do |k|
+          pretty_key = k.to_s.gsub(/_/, ' ').gsub(/\w+/){ |w| (w =~ /(ssh)|(aws)/i) ? w.upcase  : w.capitalize }
+          if Chef::Config[:knife][k].nil?
+            errors << "You did not provided a valid '#{pretty_key}' value."
+          end
+        end
+
+        if errors.each{|e| ui.error(e)}.any?
+          exit 1
+        end
+      end
+
+    end
+  end
+end
+
+

data/lib/chef/knife/ec2_server_create.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2010-2011 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,20 +17,20 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
+require 'chef/knife/ec2_base'
 
 class Chef
   class Knife
     class Ec2ServerCreate < Knife
 
+      include Knife::Ec2Base
+
       deps do
-        require 'chef/knife/bootstrap'
-        Chef::Knife::Bootstrap.load_deps
         require 'fog'
-        require 'socket'
-        require 'net/ssh/multi'
         require 'readline'
         require 'chef/json_compat'
+        require 'chef/knife/bootstrap'
+        Chef::Knife::Bootstrap.load_deps
       end
 
       banner "knife ec2 server create (options)"
@@ -90,18 +91,6 @@ class Chef
         :long => "--identity-file IDENTITY_FILE",
         :description => "The SSH identity file used for authentication"
 
-      option :aws_access_key_id,
-        :short => "-A ID",
-        :long => "--aws-access-key-id KEY",
-        :description => "Your AWS Access Key ID",
-        :proc => Proc.new { |key| Chef::Config[:knife][:aws_access_key_id] = key }
-
-      option :aws_secret_access_key,
-        :short => "-K SECRET",
-        :long => "--aws-secret-access-key SECRET",
-        :description => "Your AWS API Secret Access Key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:aws_secret_access_key] = key }
-
       option :prerelease,
         :long => "--prerelease",
         :description => "Install the pre-release chef gems"
@@ -111,12 +100,6 @@ class Chef
         :description => "The version of Chef to install",
         :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
 
-      option :region,
-        :long => "--region REGION",
-        :description => "Your AWS region",
-        :default => "us-east-1",
-        :proc => Proc.new { |key| Chef::Config[:knife][:region] = key }
-
       option :distro,
         :short => "-d DISTRO",
         :long => "--distro DISTRO",
@@ -157,6 +140,13 @@ class Chef
         :boolean => true,
         :default => false
 
+      option :aws_user_data,
+        :long => "--user-data USER_DATA_FILE",
+        :short => "-u USER_DATA_FILE",
+        :description => "The EC2 User Data file to provision the instance with",
+        :proc => Proc.new { |m| Chef::Config[:knife][:aws_user_data] = m },
+        :default => nil
+
       def tcp_test_ssh(hostname)
         tcp_socket = TCPSocket.new(hostname, 22)
         readable = IO.select([tcp_socket], nil, nil, 5)
@@ -167,6 +157,9 @@ class Chef
         else
           false
         end
+      rescue SocketError
+        sleep 2
+        false
       rescue Errno::ETIMEDOUT
         false
       rescue Errno::EPERM
@@ -183,134 +176,87 @@ class Chef
       end
 
       def run
-
         $stdout.sync = true
 
-        connection = Fog::Compute.new(
-          :provider => 'AWS',
-          :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
-          :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
-          :region => locate_config_value(:region)
-        )
-
-        ami = connection.images.get(locate_config_value(:image))
-
-        if ami.nil?
-          ui.error("You have not provided a valid image (AMI) value.  Please note the short option for this value recently changed from '-i' to '-I'.")
-          exit 1
-        end
-
-        server_def = {
-          :image_id => locate_config_value(:image),
-          :groups => config[:security_groups],
-          :flavor_id => locate_config_value(:flavor),
-          :key_name => Chef::Config[:knife][:aws_ssh_key_id],
-          :availability_zone => Chef::Config[:knife][:availability_zone]
-        }
-        server_def[:subnet_id] = config[:subnet_id] if config[:subnet_id]
+        validate!
 
-      if ami.root_device_type == "ebs"
-        ami_map = ami.block_device_mapping.first
-        ebs_size = begin
-                     if config[:ebs_size]
-                       Integer(config[:ebs_size]).to_s
-                     else
-                       ami_map["volumeSize"].to_s
-                     end
-                   rescue ArgumentError
-                     puts "--ebs-size must be an integer"
-                     msg opt_parser
-                     exit 1
-                   end
-        delete_term = if config[:ebs_no_delete_on_term]
-                        "false"
-                      else
-                        ami_map["deleteOnTermination"]
-                      end
-        server_def[:block_device_mapping] =
-          [{
-             'DeviceName' => ami_map["deviceName"],
-             'Ebs.VolumeSize' => ebs_size,
-             'Ebs.DeleteOnTermination' => delete_term
-           }]
-      end
-        server = connection.servers.create(server_def)
+        server = connection.servers.create(create_server_def)
 
-        puts "#{ui.color("Instance ID", :cyan)}: #{server.id}"
-        puts "#{ui.color("Flavor", :cyan)}: #{server.flavor_id}"
-        puts "#{ui.color("Image", :cyan)}: #{server.image_id}"
-        puts "#{ui.color("Availability Zone", :cyan)}: #{server.availability_zone}"
-        puts "#{ui.color("Security Groups", :cyan)}: #{server.groups.join(", ")}"
-        puts "#{ui.color("SSH Key", :cyan)}: #{server.key_name}"
-        puts "#{ui.color("Subnet ID", :cyan)}: #{server.subnet_id}" if vpc_mode?
+        msg_pair("Instance ID", server.id)
+        msg_pair("Flavor", server.flavor_id)
+        msg_pair("Image", server.image_id)
+        msg_pair("Region", connection.instance_variable_get(:@region))
+        msg_pair("Availability Zone", server.availability_zone)
+        msg_pair("Security Groups", server.groups.join(", "))
+        msg_pair("SSH Key", server.key_name)
 
         print "\n#{ui.color("Waiting for server", :magenta)}"
 
-        display_name = if vpc_mode?
-          server.private_ip_address
-        else
-          server.dns_name
-        end
-
         # wait for it to be ready to do stuff
         server.wait_for { print "."; ready? }
 
         puts("\n")
-
-        if !vpc_mode?
-          puts "#{ui.color("Public DNS Name", :cyan)}: #{server.dns_name}"
-          puts "#{ui.color("Public IP Address", :cyan)}: #{server.public_ip_address}"
-          puts "#{ui.color("Private DNS Name", :cyan)}: #{server.private_dns_name}"
+        
+        if vpc_mode?
+          msg_pair("Subnet ID", server.subnet_id)
+        else
+          msg_pair("Public DNS Name", server.dns_name)
+          msg_pair("Public IP Address", server.public_ip_address)
+          msg_pair("Private DNS Name", server.private_dns_name)
         end
-        puts "#{ui.color("Private IP Address", :cyan)}: #{server.private_ip_address}"
+        msg_pair("Private IP Address", server.private_ip_address)
 
         print "\n#{ui.color("Waiting for sshd", :magenta)}"
-
-        ip_to_test = vpc_mode? ? server.private_ip_address : server.public_ip_address
-        print(".") until tcp_test_ssh(ip_to_test) {
+        
+        fqdn = vpc_mode? ? server.private_ip_address : server.dns_name
+        
+        print(".") until tcp_test_ssh(fqdn) {
           sleep @initial_sleep_delay ||= (vpc_mode? ? 40 : 10)
           puts("done")
         }
 
-        bootstrap_for_node(server).run
+        bootstrap_for_node(server,fqdn).run
 
         puts "\n"
-        puts "#{ui.color("Instance ID", :cyan)}: #{server.id}"
-        puts "#{ui.color("Flavor", :cyan)}: #{server.flavor_id}"
-        puts "#{ui.color("Image", :cyan)}: #{server.image_id}"
-        puts "#{ui.color("Availability Zone", :cyan)}: #{server.availability_zone}"
-        puts "#{ui.color("Security Groups", :cyan)}: #{server.groups.join(", ")}"
-        if vpc_mode?
-          puts "#{ui.color("Subnet ID", :cyan)}: #{server.subnet_id}"
-        else
-          puts "#{ui.color("Public DNS Name", :cyan)}: #{server.dns_name}"
-          puts "#{ui.color("Public IP Address", :cyan)}: #{server.public_ip_address}"
-          puts "#{ui.color("Private DNS Name", :cyan)}: #{server.private_dns_name}"
-        end
-        puts "#{ui.color("SSH Key", :cyan)}: #{server.key_name}"
-        puts "#{ui.color("Private IP Address", :cyan)}: #{server.private_ip_address}"
-        puts "#{ui.color("Root Device Type", :cyan)}: #{server.root_device_type}"
+        msg_pair("Instance ID", server.id)
+        msg_pair("Flavor", server.flavor_id)
+        msg_pair("Image", server.image_id)
+        msg_pair("Region", connection.instance_variable_get(:@region))
+        msg_pair("Availability Zone", server.availability_zone)
+        msg_pair("Security Groups", server.groups.join(", "))
+        msg_pair("SSH Key", server.key_name)
+        msg_pair("Root Device Type", server.root_device_type)
         if server.root_device_type == "ebs"
           device_map = server.block_device_mapping.first
-          puts "#{ui.color("Root Volume ID", :cyan)}: #{device_map['volumeId']}"
-          puts "#{ui.color("Root Device Name", :cyan)}: #{device_map['deviceName']}"
-          puts "#{ui.color("Root Device Delete on Terminate", :cyan)}: #{device_map['deleteOnTermination']}"
+          msg_pair("Root Volume ID", device_map['volumeId'])
+          msg_pair("Root Device Name", device_map['deviceName'])
+          msg_pair("Root Device Delete on Terminate", device_map['deleteOnTermination'])
+
           if config[:ebs_size]
             if ami.block_device_mapping.first['volumeSize'].to_i < config[:ebs_size].to_i
-              puts ("#{ui.color("Warning", :yellow)}: #{config[:ebs_size]}GB " +
-                    "EBS volume size is larger than size set in AMI of " +
-                    "#{ami.block_device_mapping.first['volumeSize']}GB.\n" +
-                    "Use file system tools to make use of the increased volume size.")
+              volume_too_large_warning = "#{config[:ebs_size]}GB " +
+                          "EBS volume size is larger than size set in AMI of " +
+                          "#{ami.block_device_mapping.first['volumeSize']}GB.\n" +
+                          "Use file system tools to make use of the increased volume size."
+              msg_pair("Warning", volume_too_large_warning, :yellow)
             end
           end
         end
-        puts "#{ui.color("Environment", :cyan)}: #{config[:environment] || '_default'}"
-        puts "#{ui.color("Run List", :cyan)}: #{config[:run_list].join(', ')}"
+        if vpc_mode?
+          msg_pair("Subnet ID", server.subnet_id)
+        else
+          msg_pair("Public DNS Name", server.dns_name)
+          msg_pair("Public IP Address", server.public_ip_address)
+          msg_pair("Private DNS Name", server.private_dns_name)
+        end
+        msg_pair("Private IP Address", server.private_ip_address)
+        msg_pair("Environment", config[:environment] || '_default')
+        msg_pair("Run List", config[:run_list].join(', '))
       end
 
-      def bootstrap_for_node(server)
+      def bootstrap_for_node(server,fqdn)
         bootstrap = Chef::Knife::Bootstrap.new
-        bootstrap.name_args = [vpc_mode? ? server.private_ip_address : server.dns_name ]
+        bootstrap.name_args = [fqdn]
         bootstrap.config[:run_list] = config[:run_list]
         bootstrap.config[:ssh_user] = config[:ssh_user]
         bootstrap.config[:identity_file] = config[:identity_file]
@@ -318,7 +264,7 @@ class Chef
         bootstrap.config[:prerelease] = config[:prerelease]
         bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
         bootstrap.config[:distro] = locate_config_value(:distro)
-        bootstrap.config[:use_sudo] = true
+        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
         bootstrap.config[:template_file] = locate_config_value(:template_file)
         bootstrap.config[:environment] = config[:environment]
         # may be needed for vpc_mode
@@ -326,17 +272,72 @@ class Chef
         bootstrap
       end
 
-      def locate_config_value(key)
-        key = key.to_sym
-        Chef::Config[:knife][key] || config[key]
-      end
-
       def vpc_mode?
         # Amazon Virtual Private Cloud requires a subnet_id. If
         # present, do a few things differently
         !!config[:subnet_id]
       end
 
+      def ami
+        @ami ||= connection.images.get(locate_config_value(:image))
+      end
+
+      def validate!
+
+        super([:image, :aws_ssh_key_id, :aws_access_key_id, :aws_secret_access_key])
+
+        if ami.nil?
+          ui.error("You have not provided a valid image (AMI) value.  Please note the short option for this value recently changed from '-i' to '-I'.")
+          exit 1
+        end
+      end
+      
+      def create_server_def
+        server_def = {
+          :image_id => locate_config_value(:image),
+          :groups => config[:security_groups],
+          :flavor_id => locate_config_value(:flavor),
+          :key_name => Chef::Config[:knife][:aws_ssh_key_id],
+          :availability_zone => locate_config_value(:availability_zone)
+        }
+        server_def[:subnet_id] = config[:subnet_id] if config[:subnet_id]
+
+        if Chef::Config[:knife][:aws_user_data]
+          begin
+            server_def.merge!(:user_data => File.read(Chef::Config[:knife][:aws_user_data]))
+          rescue
+            ui.warn("Cannot read #{Chef::Config[:knife][:aws_user_data]}: #{$!.inspect}. Ignoring option.")
+          end
+        end
+
+        if ami.root_device_type == "ebs"
+          ami_map = ami.block_device_mapping.first
+          ebs_size = begin
+                       if config[:ebs_size]
+                         Integer(config[:ebs_size]).to_s
+                       else
+                         ami_map["volumeSize"].to_s
+                       end
+                     rescue ArgumentError
+                       puts "--ebs-size must be an integer"
+                       msg opt_parser
+                       exit 1
+                     end
+          delete_term = if config[:ebs_no_delete_on_term]
+                          "false"
+                        else
+                          ami_map["deleteOnTermination"]
+                        end
+          server_def[:block_device_mapping] =
+            [{
+               'DeviceName' => ami_map["deviceName"],
+               'Ebs.VolumeSize' => ebs_size,
+               'Ebs.DeleteOnTermination' => delete_term
+             }]
+        end
+        
+        server_def
+      end
     end
   end
 end

data/lib/chef/knife/ec2_server_delete.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2009-2011 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,73 +17,48 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
+require 'chef/knife/ec2_base'
 
 class Chef
   class Knife
     class Ec2ServerDelete < Knife
 
-      deps do
-        require 'fog'
-        require 'net/ssh/multi'
-        require 'readline'
-        require 'chef/json_compat'
-      end
+      include Knife::Ec2Base
 
       banner "knife ec2 server delete SERVER [SERVER] (options)"
 
-      option :aws_access_key_id,
-        :short => "-A ID",
-        :long => "--aws-access-key-id KEY",
-        :description => "Your AWS Access Key ID",
-        :proc => Proc.new { |key| Chef::Config[:knife][:aws_access_key_id] = key }
-
-      option :aws_secret_access_key,
-        :short => "-K SECRET",
-        :long => "--aws-secret-access-key SECRET",
-        :description => "Your AWS API Secret Access Key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:aws_secret_access_key] = key }
-
-      option :region,
-        :long => "--region REGION",
-        :description => "Your AWS region",
-        :default => "us-east-1",
-        :proc => Proc.new { |key| Chef::Config[:knife][:region] = key }
-
       def run
-        connection = Fog::Compute.new(
-          :provider => 'AWS',
-          :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
-          :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
-          :region => Chef::Config[:knife][:region] || config[:region]
-        )
+
+        validate!
 
         @name_args.each do |instance_id|
-          server = connection.servers.get(instance_id)
 
-          msg("Instance ID", server.id)
-          msg("Flavor", server.flavor_id)
-          msg("Image", server.image_id)
-          msg("Availability Zone", server.availability_zone)
-          msg("Security Groups", server.groups.join(", "))
-          msg("SSH Key", server.key_name)
-          msg("Public DNS Name", server.dns_name)
-          msg("Public IP Address", server.public_ip_address)
-          msg("Private DNS Name", server.private_dns_name)
-          msg("Private IP Address", server.private_ip_address)
+          begin
+            server = connection.servers.get(instance_id)
 
-          puts "\n"
-          confirm("Do you really want to delete this server")
+            msg_pair("Instance ID", server.id)
+            msg_pair("Flavor", server.flavor_id)
+            msg_pair("Image", server.image_id)
+            msg_pair("Region", connection.instance_variable_get(:@region))
+            msg_pair("Availability Zone", server.availability_zone)
+            msg_pair("Security Groups", server.groups.join(", "))
+            msg_pair("SSH Key", server.key_name)
+            msg_pair("Root Device Type", server.root_device_type)
+            msg_pair("Public DNS Name", server.dns_name)
+            msg_pair("Public IP Address", server.public_ip_address)
+            msg_pair("Private DNS Name", server.private_dns_name)
+            msg_pair("Private IP Address", server.private_ip_address)
 
-          server.destroy
+            puts "\n"
+            confirm("Do you really want to delete this server")
 
-          ui.warn("Deleted server #{server.id}")
-        end
-      end
+            server.destroy
+
+            ui.warn("Deleted server #{server.id}")
 
-      def msg(label, value)
-        if value && !value.empty?
-          puts "#{ui.color(label, :cyan)}: #{value}"
+          rescue NoMethodError
+            ui.error("Could not locate server '#{instance_id}'.  Please verify it was provisioned in the '#{locate_config_value(:region)}' region.")
+          end
         end
       end
 

data/lib/chef/knife/ec2_server_list.rb

@@ -1,6 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Seth Chisamore (<schisamo@opscode.com>)
+# Copyright:: Copyright (c) 2010-2011 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,48 +17,20 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
+require 'chef/knife/ec2_base'
 
 class Chef
   class Knife
     class Ec2ServerList < Knife
 
-      deps do
-        require 'fog'
-        require 'net/ssh/multi'
-        require 'readline'
-        require 'chef/json_compat'
-      end
+      include Knife::Ec2Base
 
       banner "knife ec2 server list (options)"
 
-      option :aws_access_key_id,
-        :short => "-A ID",
-        :long => "--aws-access-key-id KEY",
-        :description => "Your AWS Access Key ID",
-        :proc => Proc.new { |key| Chef::Config[:knife][:aws_access_key_id] = key }
-
-      option :aws_secret_access_key,
-        :short => "-K SECRET",
-        :long => "--aws-secret-access-key SECRET",
-        :description => "Your AWS API Secret Access Key",
-        :proc => Proc.new { |key| Chef::Config[:knife][:aws_secret_access_key] = key }
-
-      option :region,
-        :long => "--region REGION",
-        :description => "Your AWS region",
-        :default => "us-east-1",
-        :proc => Proc.new { |key| Chef::Config[:knife][:region] = key }
-
       def run
         $stdout.sync = true
 
-        connection = Fog::Compute.new(
-          :provider => 'AWS',
-          :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
-          :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
-          :region => Chef::Config[:knife][:region] || config[:region]
-        )
+        validate!
 
         server_list = [
           ui.color('Instance ID', :bold),
@@ -65,6 +38,7 @@ class Chef
           ui.color('Private IP', :bold),
           ui.color('Flavor', :bold),
           ui.color('Image', :bold),
+          ui.color('SSH Key', :bold),
           ui.color('Security Groups', :bold),
           ui.color('State', :bold)
         ]
@@ -74,10 +48,20 @@ class Chef
           server_list << (server.private_ip_address == nil ? "" : server.private_ip_address)
           server_list << (server.flavor_id == nil ? "" : server.flavor_id)
           server_list << (server.image_id == nil ? "" : server.image_id)
+          server_list << server.key_name
           server_list << server.groups.join(", ")
-          server_list << (server.state == nil ? "" : server.state)
+          server_list << begin
+            case server.state.downcase
+            when 'shutting-down','terminated','stopping','stopped'
+              ui.color(server.state.downcase, :red)
+            when 'pending'
+              ui.color(server.state.downcase, :yellow)
+            else
+              ui.color(server.state.downcase, :green)
+            end
+          end
         end
-        puts ui.list(server_list, :columns_across, 7)
+        puts ui.list(server_list, :columns_across, 8)
 
       end
     end

data/lib/knife-ec2/version.rb

@@ -1,4 +1,7 @@
-module KnifeEC2
-  VERSION = "0.5.6"
+module Knife
+  module Ec2
+    VERSION = "0.5.8"
+    MAJOR, MINOR, TINY = VERSION.split('.')
+  end
 end
 

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'chef'
+require 'chef/knife/ec2_server_create'
+require 'chef/knife/ec2_instance_data'
+require 'chef/knife/ec2_server_delete'
+require 'chef/knife/ec2_server_list'

data/spec/unit/ec2_server_create_spec.rb

@@ -0,0 +1,130 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright (c) 2010 Thomas Bishop
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Chef::Knife::Ec2ServerCreate do
+  before do
+    @knife_ec2_create = Chef::Knife::Ec2ServerCreate.new()
+    @knife_ec2_create.name_args = ['role[base]']
+    @knife_ec2_create.initial_sleep_delay = 0
+    @knife_ec2_create.stub!(:tcp_test_ssh).and_return(true)
+
+    @ec2_connection = mock()
+    @ec2_servers = mock()
+    @new_ec2_server = mock()
+
+    @ec2_server_attribs = { :id => 'i-39382318',
+                           :flavor_id => 'm1.small',
+                           :image_id => 'ami-47241231',
+                           :availability_zone => 'us-west-1',
+                           :key_name => 'my_ssh_key',
+                           :groups => ['group1', 'group2'],
+                           :dns_name => 'ec2-75.101.253.10.compute-1.amazonaws.com',
+                           :ip_address => '75.101.253.10',
+                           :private_dns_name => 'ip-10-251-75-20.ec2.internal',
+                           :private_ip_address => '10.251.75.20' }
+
+    @ec2_server_attribs.each_pair do |attrib, value|
+      @new_ec2_server.stub!(attrib).and_return(value)
+    end
+  end
+
+  describe "run" do
+
+    it "creates an EC2 instance and bootstraps it" do
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @ec2_servers.should_receive(:create).and_return(@new_ec2_server)
+      @ec2_connection.should_receive(:servers).and_return(@ec2_servers)
+
+      Fog::AWS::Compute.should_receive(:new).and_return(@ec2_connection)
+
+      @knife_ec2_create.stub!(:puts)
+      @knife_ec2_create.stub!(:print)
+      @knife_ec2_create.config[:image] = '12345'
+
+
+      @bootstrap = Chef::Knife::Bootstrap.new
+      Chef::Knife::Bootstrap.stub!(:new).and_return(@bootstrap)
+      @bootstrap.should_receive(:run)
+      @knife_ec2_create.run
+    end
+
+  end
+
+  describe "when configuring the bootstrap process" do
+    before do
+      @knife_ec2_create.config[:ssh_user] = "ubuntu"
+      @knife_ec2_create.config[:identity_file] = "~/.ssh/aws-key.pem"
+      @knife_ec2_create.config[:chef_node_name] = "blarf"
+      @knife_ec2_create.config[:template_file] = '~/.chef/templates/my-bootstrap.sh.erb'
+      @knife_ec2_create.config[:distro] = 'ubuntu-10.04-magic-sparkles'
+
+      @bootstrap = @knife_ec2_create.bootstrap_for_node(@new_ec2_server)
+    end
+
+    it "should set the bootstrap 'name argument' to the hostname of the EC2 server" do
+      @bootstrap.name_args.should == ['ec2-75.101.253.10.compute-1.amazonaws.com']
+    end
+
+    it "configures sets the bootstrap's run_list" do
+      @bootstrap.config[:run_list].should == ['role[base]']
+    end
+
+    it "configures the bootstrap to use the correct ssh_user login" do
+      @bootstrap.config[:ssh_user].should == 'ubuntu'
+    end
+
+    it "configures the bootstrap to use the correct ssh identity file" do
+      @bootstrap.config[:identity_file].should == "~/.ssh/aws-key.pem"
+    end
+
+    it "configures the bootstrap to use the configured node name if provided" do
+      @bootstrap.config[:chef_node_name].should == 'blarf'
+    end
+
+    it "configures the bootstrap to use the EC2 server id if no explicit node name is set" do
+      @knife_ec2_create.config[:chef_node_name] = nil
+
+      bootstrap = @knife_ec2_create.bootstrap_for_node(@new_ec2_server)
+      bootstrap.config[:chef_node_name].should == @new_ec2_server.id
+    end
+
+    it "configures the bootstrap to use prerelease versions of chef if specified" do
+      @bootstrap.config[:prerelease].should be_false
+
+      @knife_ec2_create.config[:prerelease] = true
+
+      bootstrap = @knife_ec2_create.bootstrap_for_node(@new_ec2_server)
+      bootstrap.config[:prerelease].should be_true
+    end
+
+    it "configures the bootstrap to use the desired distro-specific bootstrap script" do
+      @bootstrap.config[:distro].should == 'ubuntu-10.04-magic-sparkles'
+    end
+
+    it "configures the bootstrap to use sudo" do
+      @bootstrap.config[:use_sudo].should be_true
+    end
+
+    it "configured the bootstrap to use the desired template" do
+      @bootstrap.config[:template_file].should == '~/.chef/templates/my-bootstrap.sh.erb'
+    end
+  end
+
+end

metadata

@@ -2,15 +2,16 @@
 name: knife-ec2
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.6
+  version: 0.5.8
 platform: ruby
 authors: 
 - Adam Jacob
+- Seth Chisamore
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-05-13 00:00:00 -07:00
+date: 2011-08-15 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,33 +22,13 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.7.2
+        version: 0.8.2
   type: :runtime
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: net-ssh
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 2.1.3
-  type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: net-ssh-multi
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 1.0.1
-  type: :runtime
-  version_requirements: *id003
-description: EC2 Support for Chef's Knife Command
-email: adam@opscode.com
+description: Rackspace Support for Chef's Knife Command
+email: 
+- adam@opscode.com
+- schisamo@opscode.com
 executables: []
 
 extensions: []
@@ -56,13 +37,21 @@ extra_rdoc_files:
 - README.rdoc
 - LICENSE
 files: 
+- .gitignore
+- .rspec
+- Gemfile
 - LICENSE
 - README.rdoc
+- Rakefile
+- knife-ec2.gemspec
+- lib/chef/knife/ec2_base.rb
 - lib/chef/knife/ec2_instance_data.rb
 - lib/chef/knife/ec2_server_create.rb
 - lib/chef/knife/ec2_server_delete.rb
 - lib/chef/knife/ec2_server_list.rb
 - lib/knife-ec2/version.rb
+- spec/spec_helper.rb
+- spec/unit/ec2_server_create_spec.rb
 has_rdoc: true
 homepage: http://wiki.opscode.com/display/chef
 licenses: []
@@ -90,6 +79,7 @@ rubyforge_project:
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: EC2 Support for Chef's Knife Command
-test_files: []
-
+summary: Rackspace Support for Chef's Knife Command
+test_files: 
+- spec/spec_helper.rb
+- spec/unit/ec2_server_create_spec.rb