knife-ec2 0.6.2 → 0.6.4

data/Rakefile

@@ -23,7 +23,7 @@ Bundler::GemHelper.install_tasks
 
 # require 'rubygems'
 # require 'rake/gempackagetask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 begin
   require 'sdoc'

data/lib/chef/knife/ec2_server_create.rb

@@ -62,6 +62,10 @@ class Chef
         :description => "The security group ids for this server; required when using VPC",
         :proc => Proc.new { |security_group_ids| security_group_ids.split(',') }
 
+      option :associate_eip,
+        :long => "--associate-eip IP_ADDRESS",
+        :description => "Associate existing elastic IP address with instance after launch"
+
       option :tags,
         :short => "-T T=V[,T=V,...]",
         :long => "--tags Tag=Value[,Tag=Value...]",
@@ -110,7 +114,6 @@ class Chef
         :description => "The ssh gateway server",
         :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
 
-
       option :identity_file,
         :short => "-i IDENTITY_FILE",
         :long => "--identity-file IDENTITY_FILE",
@@ -167,6 +170,11 @@ class Chef
         :description => "create node in this Virtual Private Cloud Subnet ID (implies VPC mode)",
         :proc => Proc.new { |key| Chef::Config[:knife][:subnet_id] = key }
 
+      option :private_ip_address,
+        :long => "--private-ip-address IP-ADDRESS",
+        :description => "allows to specify the private IP address of the instance in VPC mode",
+        :proc => Proc.new { |ip| Chef::Config[:knife][:private_ip_address] = ip }
+
       option :host_key_verify,
         :long => "--[no-]host-key-verify",
         :description => "Verify host key, enabled by default.",
@@ -225,6 +233,11 @@ class Chef
 
         validate!
 
+        requested_elastic_ip = config[:associate_eip] if config[:associate_eip]
+
+        # For VPC EIP assignment we need the allocation ID so fetch full EIP details
+        elastic_ip = connection.addresses.detect{|addr| addr if addr.public_ip == requested_elastic_ip}
+
         @server = connection.servers.create(create_server_def)
 
         hashed_tags={}
@@ -235,10 +248,6 @@ class Chef
           hashed_tags["Name"] = locate_config_value(:chef_node_name) || @server.id
         end
 
-        hashed_tags.each_pair do |key,val|
-          connection.tags.create :key => key, :value => val, :resource_id => @server.id
-        end
-
         msg_pair("Instance ID", @server.id)
         msg_pair("Flavor", @server.flavor_id)
         msg_pair("Image", @server.image_id)
@@ -260,15 +269,30 @@ class Chef
         msg_pair("Tags", hashed_tags)
         msg_pair("SSH Key", @server.key_name)
 
-        print "\n#{ui.color("Waiting for server", :magenta)}"
+        print "\n#{ui.color("Waiting for instance", :magenta)}"
 
-        # wait for it to be ready to do stuff
+        # wait for instance to come up before acting against it
         @server.wait_for { print "."; ready? }
 
         puts("\n")
 
+        # occasionally 'ready?' isn't, so retry a couple times if needed.
+        tries = 6 
+        begin
+          create_tags(hashed_tags) unless hashed_tags.empty?
+          associate_eip(elastic_ip) if config[:associate_eip]
+        rescue Fog::Compute::AWS::NotFound => e
+          raise if (tries -= 1) <= 0
+          ui.warn("server not ready, retrying tag application (retries left: #{tries})")
+          sleep 5
+          retry
+        end
+
         if vpc_mode?
           msg_pair("Subnet ID", @server.subnet_id)
+          if elastic_ip
+            msg_pair("Public IP Address", @server.public_ip_address)
+          end
         else
           msg_pair("Public DNS Name", @server.dns_name)
           msg_pair("Public IP Address", @server.public_ip_address)
@@ -373,7 +397,19 @@ class Chef
           ui.error("You are using a VPC, security groups specified with '-G' are not allowed, specify one or more security group ids with '-g' instead.")
           exit 1
         end
+        if !vpc_mode? and !!config[:private_ip_address]
+          ui.error("You can only specify a private IP address if you are using VPC.")
+          exit 1
+        end
+
+        if config[:associate_eip]
+          eips = connection.addresses.collect{|addr| addr if addr.domain == eip_scope}.compact
 
+          unless eips.detect{|addr| addr.public_ip == config[:associate_eip] && addr.server_id == nil}
+            ui.error("Elastic IP requested is not available.")
+            exit 1
+          end
+        end
       end
 
       def tags
@@ -385,6 +421,14 @@ class Chef
        tags
       end
 
+      def eip_scope
+        if vpc_mode?
+          "vpc"
+        else
+          "standard"
+        end
+      end
+
       def create_server_def
         server_def = {
           :image_id => locate_config_value(:image),
@@ -395,6 +439,7 @@ class Chef
           :availability_zone => locate_config_value(:availability_zone)
         }
         server_def[:subnet_id] = locate_config_value(:subnet_id) if vpc_mode?
+        server_def[:private_ip_address] = locate_config_value(:private_ip_address) if vpc_mode?
 
         if Chef::Config[:knife][:aws_user_data]
           begin
@@ -486,6 +531,17 @@ class Chef
           vpc_mode? ? server.private_ip_address : server.dns_name
         end
       end
+
+      def create_tags(hashed_tags)
+        hashed_tags.each_pair do |key,val|
+          connection.tags.create :key => key, :value => val, :resource_id => @server.id
+        end
+      end
+
+      def associate_eip(elastic_ip)
+        connection.associate_address(server.id, elastic_ip.public_ip, nil, elastic_ip.allocation_id)
+        @server.wait_for { public_ip_address == elastic_ip.public_ip }
+      end
     end
   end
 end

data/lib/knife-ec2/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Ec2
-    VERSION = "0.6.2"
+    VERSION = "0.6.4"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

data/spec/unit/ec2_server_create_spec.rb

@@ -38,6 +38,13 @@ describe Chef::Knife::Ec2ServerCreate do
     @ec2_connection = mock(Fog::Compute::AWS)
     @ec2_connection.stub_chain(:tags).and_return mock('create', :create => true)
     @ec2_connection.stub_chain(:images, :get).and_return mock('ami', :root_device_type => 'not_ebs')
+    @ec2_connection.stub_chain(:addresses).and_return [mock('addesses', {
+            :domain => 'standard',
+            :public_ip => '111.111.111.111',
+            :server_id => nil,
+            :allocation_id => ''})]
+
+
     @ec2_servers = mock()
     @new_ec2_server = mock()
 
@@ -60,30 +67,56 @@ describe Chef::Knife::Ec2ServerCreate do
   end
 
   describe "run" do
-    it "creates an EC2 instance and bootstraps it" do
-      @new_ec2_server.should_receive(:wait_for).and_return(true)
+    before do
       @ec2_servers.should_receive(:create).and_return(@new_ec2_server)
       @ec2_connection.should_receive(:servers).and_return(@ec2_servers)
+      @ec2_connection.should_receive(:addresses)
 
+      @eip = "111.111.111.111"
       Fog::Compute::AWS.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)
+    end
+
+    it "creates an EC2 instance and bootstraps it" do
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.run
+      @knife_ec2_create.server.should_not == nil
+    end
+
+    it "creates an EC2 instance, assigns existing EIP and bootstraps it" do
+      @knife_ec2_create.config[:associate_eip] = @eip
+
+      @new_ec2_server.stub!(:public_ip_address).and_return(@eip)
+      @ec2_connection.should_receive(:associate_address).with(@ec2_server_attribs[:id], @eip, nil, '')
+      @new_ec2_server.should_receive(:wait_for).at_least(:twice).and_return(true)
+
       @knife_ec2_create.run
       @knife_ec2_create.server.should_not == nil
     end
+
+    it "retries if it receives Fog::Compute::AWS::NotFound" do
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.should_receive(:create_tags).and_raise(Fog::Compute::AWS::NotFound)
+      @knife_ec2_create.should_receive(:create_tags).and_return(true)
+      @knife_ec2_create.should_receive(:sleep).and_return(true)
+      @knife_ec2_create.ui.should_receive(:warn).with(/retrying/)
+      @knife_ec2_create.run
+    end
   end
+
   describe "when setting tags" do
     before do
       Fog::Compute::AWS.should_receive(:new).and_return(@ec2_connection)
       @knife_ec2_create.stub!(:bootstrap_for_node).and_return mock("bootstrap", :run => true)
       @ec2_connection.stub!(:servers).and_return(@ec2_servers)
+      @ec2_connection.should_receive(:addresses)
       @new_ec2_server.stub!(:wait_for).and_return(true)
       @ec2_servers.stub!(:create).and_return(@new_ec2_server)
       @knife_ec2_create.stub!(:puts)
@@ -216,6 +249,12 @@ describe Chef::Knife::Ec2ServerCreate do
 
       lambda { @knife_ec2_create.validate! }.should raise_error SystemExit
     end
+
+    it "disallows private ips when not using a VPC" do
+      @knife_ec2_create.config[:private_ip_address] = '10.0.0.10'
+
+      lambda { @knife_ec2_create.validate! }.should raise_error SystemExit
+    end
   end
 
   describe "when creating the server definition" do
@@ -270,6 +309,15 @@ describe Chef::Knife::Ec2ServerCreate do
                                                    { "VirtualName" => "ephemeral2", "DeviceName" => "/dev/sdd" },
                                                    { "VirtualName" => "ephemeral3", "DeviceName" => "/dev/sde" }]
     end
+
+    it "sets the specified private ip address" do
+      @knife_ec2_create.config[:subnet_id] = 'subnet-1a2b3c4d'
+      @knife_ec2_create.config[:private_ip_address] = '10.0.0.10'
+      server_def = @knife_ec2_create.create_server_def
+
+      server_def[:subnet_id].should == 'subnet-1a2b3c4d'
+      server_def[:private_ip_address].should == '10.0.0.10'
+    end
   end
 
   describe "ssh_connect_host" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-ec2
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.4
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-24 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog