kitchen-ec2 0.8.0 → 0.9.0

data/Rakefile

@@ -1,21 +1,39 @@
-require "bundler/gem_tasks"
-require 'cane/rake_task'
-require 'tailor/rake_task'
+# -*- encoding: utf-8 -*-
 
-desc "Run cane to check quality metrics"
-Cane::RakeTask.new do |cane|
-  cane.canefile = './.cane'
-end
+require "bundler/gem_tasks"
 
-Tailor::RakeTask.new
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:test)
 
 desc "Display LOC stats"
 task :stats do
   puts "\n## Production Code Stats"
-  sh "countloc -r lib/kitchen"
+  sh "countloc -r lib/kitchen lib/kitchen.rb"
+  puts "\n## Test Code Stats"
+  sh "countloc -r spec features"
+end
+
+require "finstyle"
+require "rubocop/rake_task"
+RuboCop::RakeTask.new(:style) do |task|
+  task.options << "--display-cop-names"
+end
+
+if RUBY_ENGINE != "jruby"
+  require "cane/rake_task"
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new do |cane|
+    cane.canefile = "./.cane"
+  end
+
+  desc "Run all quality tasks"
+  task :quality => [:cane, :style, :stats]
+else
+  desc "Run all quality tasks"
+  task :quality => [:style, :stats]
 end
 
-desc "Run all quality tasks"
-task :quality => [:cane, :tailor, :stats]
+require "yard"
+YARD::Rake::YardocTask.new
 
-task :default => [:quality]
+task :default => [:test, :quality]

data/data/amis.json

@@ -5,6 +5,8 @@
       "ubuntu-12.04": "ami-bb9a08ba",
       "ubuntu-12.10": "ami-4556c544",
       "ubuntu-13.04": "ami-97099a96",
+      "ubuntu-13.10": "ami-45f1a744",
+      "ubuntu-14.04": "ami-955c0c94",
       "centos-6.4": "ami-9ffa709e",
       "debian-7.1.0": "ami-f1f064f0"
     },
@@ -13,6 +15,8 @@
       "ubuntu-12.04": "ami-881c57da",
       "ubuntu-12.10": "ami-3ce0a86e",
       "ubuntu-13.04": "ami-4af5bd18",
+      "ubuntu-13.10": "ami-02e6b850",
+      "ubuntu-14.04": "ami-9a7c25c8",
       "centos-6.4": "ami-46f5bb14",
       "debian-7.1.0": "ami-fe8ac3ac"
     },
@@ -21,6 +25,8 @@
       "ubuntu-12.04": "ami-cb26b4f1",
       "ubuntu-12.10": "ami-1703912d",
       "ubuntu-13.04": "ami-8f32a0b5",
+      "ubuntu-13.10": "ami-e54423df",
+      "ubuntu-14.04": "ami-f3b1d6c9",
       "centos-6.4": "ami-9352c1a9",
       "debian-7.1.0": "ami-4e099a74"
     },
@@ -29,6 +35,8 @@
       "ubuntu-12.04": "ami-d3b5aea7",
       "ubuntu-12.10": "ami-6b62791f",
       "ubuntu-13.04": "ami-6fd4cf1b",
+      "ubuntu-13.10": "ami-39eb3f4e",
+      "ubuntu-14.04": "ami-c112c5b6",
       "centos-6.4": "ami-75190b01",
       "debian-7.1.0": "ami-954559e1"
     },
@@ -37,6 +45,8 @@
       "ubuntu-12.04": "ami-c905a1d4",
       "ubuntu-12.10": "ami-e759fdfa",
       "ubuntu-13.04": "ami-4b2b8f56",
+      "ubuntu-13.10": "ami-076cc21a",
+      "ubuntu-14.04": "ami-052b8518",
       "centos-6.4": "ami-a665c0bb",
       "debian-7.1.0": "ami-b03590ad"
     },
@@ -45,6 +55,8 @@
       "ubuntu-12.04": "ami-2f115c46",
       "ubuntu-12.10": "ami-4d5b1824",
       "ubuntu-13.04": "ami-a73371ce",
+      "ubuntu-13.10": "ami-a65393ce",
+      "ubuntu-14.04": "ami-4a915c22",
       "centos-6.4": "ami-bf5021d6",
       "debian-7.1.0": "ami-50d9a439"
     },
@@ -53,6 +65,8 @@
       "ubuntu-12.04": "ami-eaf0daaf",
       "ubuntu-12.10": "ami-02220847",
       "ubuntu-13.04": "ami-fe052fbb",
+      "ubuntu-13.10": "ami-bb2a2afe",
+      "ubuntu-14.04": "ami-d99a9a9c",
       "centos-6.4": "ami-5d456c18",
       "debian-7.1.0": "ami-1a9bb25f"
     },
@@ -61,6 +75,8 @@
       "ubuntu-12.04": "ami-e6f36fd6",
       "ubuntu-12.10": "ami-0c069b3c",
       "ubuntu-13.04": "ami-4ade427a",
+      "ubuntu-13.10": "ami-c18ff1f1",
+      "ubuntu-14.04": "ami-b7720b87",
       "centos-6.4": "ami-b3bf2f83",
       "debian-7.1.0": "ami-158a1925"
     }
@@ -70,6 +86,8 @@
     "ubuntu-12.04": "ubuntu",
     "ubuntu-12.10": "ubuntu",
     "ubuntu-13.04": "ubuntu",
+    "ubuntu-13.10": "ubuntu",
+    "ubuntu-14.04": "ubuntu",
     "centos-6.4": "root",
     "debian-7.1.0": "admin"
   },

data/kitchen-ec2.gemspec

@@ -1,28 +1,39 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'kitchen/driver/ec2_version.rb'
+require "kitchen/driver/ec2_version.rb"
 
 Gem::Specification.new do |gem|
   gem.name          = "kitchen-ec2"
   gem.version       = Kitchen::Driver::EC2_VERSION
-  gem.license       = 'Apache 2.0'
+  gem.license       = "Apache 2.0"
   gem.authors       = ["Fletcher Nichol"]
   gem.email         = ["fnichol@nichol.ca"]
   gem.description   = "A Test Kitchen Driver for Amazon EC2"
   gem.summary       = gem.description
   gem.homepage      = "http://kitchen.ci/"
 
-  gem.files         = `git ls-files`.split($/)
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.executables   = []
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'test-kitchen', '~> 1.0'
-  gem.add_dependency 'fog'
+  gem.add_dependency "test-kitchen", "~> 1.4"
+  gem.add_dependency "excon"
+  gem.add_dependency "multi_json"
+  gem.add_dependency "aws-sdk-v1", "~> 1.59.0"
+  gem.add_dependency "aws-sdk", "~> 2"
 
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'cane'
-  gem.add_development_dependency 'tailor'
-  gem.add_development_dependency 'countloc'
+  gem.add_development_dependency "rspec",     "~> 3.2"
+  gem.add_development_dependency "countloc",  "~> 0.4"
+  gem.add_development_dependency "maruku",    "~> 0.6"
+  gem.add_development_dependency "simplecov", "~> 0.7"
+  gem.add_development_dependency "yard",      "~> 0.8"
+
+  # style and complexity libraries are tightly version pinned as newer releases
+  # may introduce new and undesireable style choices which would be immediately
+  # enforced in CI
+  gem.add_development_dependency "finstyle",  "1.4.0"
+  gem.add_development_dependency "cane",      "2.6.2"
+  gem.add_development_dependency "climate_control"
 end

data/lib/kitchen/driver/aws/client.rb

@@ -0,0 +1,110 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+#
+# Copyright (C) 2015, Fletcher Nichol
+#
+# 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 "aws-sdk"
+require "aws-sdk-core/credentials"
+require "aws-sdk-core/shared_credentials"
+require "aws-sdk-core/instance_profile_credentials"
+
+module Kitchen
+
+  module Driver
+
+    class Aws
+
+      # A class for creating and managing the EC2 client connection
+      #
+      # @author Tyler Ball <tball@chef.io>
+      class Client
+
+        def initialize(
+          region,
+          profile_name = nil,
+          access_key_id = nil,
+          secret_access_key = nil,
+          session_token = nil
+        )
+          creds = self.class.get_credentials(
+            profile_name, access_key_id, secret_access_key, session_token
+          )
+          ::Aws.config.update(
+            :region => region,
+            :credentials => creds
+          )
+        end
+
+        # Try and get the credentials from an ordered list of locations
+        # http://docs.aws.amazon.com/sdkforruby/api/index.html#Configuration
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def self.get_credentials(profile_name, access_key_id, secret_access_key, session_token)
+          shared_creds = ::Aws::SharedCredentials.new(:profile_name => profile_name)
+          if access_key_id && secret_access_key
+            ::Aws::Credentials.new(access_key_id, secret_access_key, session_token)
+          # TODO: these are deprecated, remove them in the next major version
+          elsif ENV["AWS_ACCESS_KEY"] && ENV["AWS_SECRET_KEY"]
+            ::Aws::Credentials.new(
+              ENV["AWS_ACCESS_KEY"],
+              ENV["AWS_SECRET_KEY"],
+              ENV["AWS_TOKEN"]
+            )
+          elsif ENV["AWS_ACCESS_KEY_ID"] && ENV["AWS_SECRET_ACCESS_KEY"]
+            ::Aws::Credentials.new(
+              ENV["AWS_ACCESS_KEY_ID"],
+              ENV["AWS_SECRET_ACCESS_KEY"],
+              ENV["AWS_SESSION_TOKEN"]
+            )
+          elsif shared_creds.loadable?
+            shared_creds
+          else
+            ::Aws::InstanceProfileCredentials.new(:retries => 1)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def create_instance(options)
+          resource.create_instances(options)[0]
+        end
+
+        def get_instance(id)
+          resource.instance(id)
+        end
+
+        def get_instance_from_spot_request(request_id)
+          resource.instances(
+            :filters => [{
+              :name => "spot-instance-request-id",
+              :values => [request_id]
+            }]
+          ).to_a[0]
+        end
+
+        def client
+          @client ||= ::Aws::EC2::Client.new
+        end
+
+        def resource
+          @resource ||= ::Aws::EC2::Resource.new
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/kitchen/driver/aws/instance_generator.rb

@@ -0,0 +1,148 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Tyler Ball (<tball@chef.io>)
+#
+# Copyright (C) 2015, Fletcher Nichol
+#
+# 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 "kitchen/logging"
+
+module Kitchen
+
+  module Driver
+
+    class Aws
+
+      # A class for encapsulating the instance payload logic
+      #
+      # @author Tyler Ball <tball@chef.io>
+      class InstanceGenerator
+
+        include Logging
+
+        attr_reader :config, :ec2
+
+        def initialize(config, ec2)
+          @config = config
+          @ec2 = ec2
+        end
+
+        # Transform the provided config into the hash to send to AWS.  Some fields
+        # can be passed in null, others need to be ommitted if they are null
+        def ec2_instance_data # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          i = {
+            :placement => {
+              :availability_zone          => config[:availability_zone]
+            },
+            :instance_type                => config[:instance_type],
+            :ebs_optimized                => config[:ebs_optimized],
+            :image_id                     => config[:image_id],
+            :key_name                     => config[:aws_ssh_key_id],
+            :subnet_id                    => config[:subnet_id],
+            :private_ip_address           => config[:private_ip_address]
+          }
+          i[:block_device_mappings] = block_device_mappings unless block_device_mappings.empty?
+          i[:security_group_ids] = config[:security_group_ids] if config[:security_group_ids]
+          i[:user_data] = prepared_user_data if prepared_user_data
+          if config[:iam_instance_profile]
+            i[:iam_instance_profile] = { :name => config[:iam_profile_name] }
+          end
+          if !config.fetch(:associate_public_ip_address, nil).nil?
+            i[:network_interfaces] =
+              [{
+                :device_index => 0,
+                :associate_public_ip_address => config[:associate_public_ip_address]
+              }]
+          end
+          i
+        end
+
+        # Transforms the provided config into the appropriate hash for creating a BDM
+        # in AWS
+        def block_device_mappings # rubocop:disable all
+          return @bdms if @bdms
+          bdms = config[:block_device_mappings] || []
+          if bdms.empty?
+            if config[:ebs_volume_size] || config.fetch(:ebs_delete_on_termination, nil) ||
+                config[:ebs_device_name] || config[:ebs_volume_type]
+              # If the user didn't supply block_device_mappings but did supply
+              # the old configs, copy them into the block_device_mappings array correctly
+              # TODO: remove this logic when we remove the deprecated values
+              bdms << {
+                :ebs_volume_size => config[:ebs_volume_size] || 8,
+                :ebs_delete_on_termination => config.fetch(:ebs_delete_on_termination, true),
+                :ebs_device_name => config[:ebs_device_name] || "/dev/sda1",
+                :ebs_volume_type => config[:ebs_volume_type] || "standard"
+              }
+            end
+          end
+
+          # Convert the provided keys to what AWS expects
+          bdms = bdms.map do |bdm|
+            b = {
+              :ebs => {
+                :volume_size           => bdm[:ebs_volume_size],
+                :delete_on_termination => bdm[:ebs_delete_on_termination]
+              },
+              :device_name             => bdm[:ebs_device_name]
+            }
+            b[:ebs][:volume_type] = bdm[:ebs_volume_type] if bdm[:ebs_volume_type]
+            b[:ebs][:snapshot_id] = bdm[:ebs_snapshot_id] if bdm[:ebs_snapshot_id]
+            b[:virtual_name] = bdm[:ebs_virtual_name] if bdm[:ebs_virtual_name]
+            b
+          end
+
+          debug_if_root_device(bdms)
+
+          @bdms = bdms
+        end
+
+        # If the provided bdms match the root device in the AMI, emit log that
+        # states this
+        def debug_if_root_device(bdms)
+          image_id = config[:image_id]
+          image = ec2.resource.image(image_id)
+          begin
+            root_device_name = image.root_device_name
+          rescue ::Aws::EC2::Errors::InvalidAMIIDNotFound
+            # Not raising here because AWS will give a more meaningful message
+            # when we try to create the instance
+            return
+          end
+          bdms.find { |bdm|
+            if bdm[:device_name] == root_device_name
+              info("Overriding root device [#{root_device_name}] from image [#{image_id}]")
+            end
+          }
+        end
+
+        def prepared_user_data
+          # If user_data is a file reference, lets read it as such
+          unless @user_data
+            if config[:user_data] && File.file?(config[:user_data])
+              @user_data = File.read(config[:user_data])
+            else
+              @user_data = config[:user_data]
+            end
+          end
+          @user_data
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/kitchen/driver/ec2.rb

@@ -2,7 +2,7 @@
 #
 # Author:: Fletcher Nichol (<fnichol@nichol.ca>)
 #
-# Copyright (C) 2012, Fletcher Nichol
+# Copyright (C) 2015, Fletcher Nichol
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,10 +16,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'benchmark'
-require 'json'
-require 'fog'
-require 'kitchen'
+require "benchmark"
+require "json"
+require "aws"
+require "kitchen"
+require "kitchen/driver/ec2_version"
+require_relative "aws/client"
+require_relative "aws/instance_generator"
 
 module Kitchen
 
@@ -28,143 +31,340 @@ module Kitchen
     # Amazon EC2 driver for Test Kitchen.
     #
     # @author Fletcher Nichol <fnichol@nichol.ca>
-    class Ec2 < Kitchen::Driver::SSHBase
+    class Ec2 < Kitchen::Driver::Base # rubocop:disable Metrics/ClassLength
 
-      default_config :region,             'us-east-1'
-      default_config :availability_zone,  'us-east-1b'
-      default_config :flavor_id,          'm1.small'
+      kitchen_driver_api_version 2
+
+      plugin_version Kitchen::Driver::EC2_VERSION
+
+      default_config :region,             ENV["AWS_REGION"] || "us-east-1"
+      default_config :shared_credentials_profile, nil
+      default_config :availability_zone,  nil
+      default_config :flavor_id,          nil
+      default_config :instance_type,      nil
       default_config :ebs_optimized,      false
-      default_config :security_group_ids, ['default']
-      default_config :tags,               { 'created-by' => 'test-kitchen' }
-      default_config :aws_access_key_id do |driver|
-        ENV['AWS_ACCESS_KEY'] || ENV['AWS_ACCESS_KEY_ID']
+      default_config :security_group_ids, nil
+      default_config :tags,                "created-by" => "test-kitchen"
+      default_config :user_data,          nil
+      default_config :private_ip_address, nil
+      default_config :iam_profile_name,   nil
+      default_config :price,              nil
+      default_config :retryable_tries,    60
+      default_config :retryable_sleep,    5
+      default_config :aws_access_key_id,  nil
+      default_config :aws_secret_access_key, nil
+      default_config :aws_session_token,  nil
+      default_config :aws_ssh_key_id,     ENV["AWS_SSH_KEY_ID"]
+      default_config :image_id do |driver|
+        driver.default_ami
       end
-      default_config :aws_secret_access_key do |driver|
-        ENV['AWS_SECRET_KEY'] || ENV['AWS_SECRET_ACCESS_KEY']
+      default_config :username,            nil
+      default_config :associate_public_ip, nil
+
+      required_config :aws_ssh_key_id
+      required_config :image_id
+
+      def self.validation_warn(driver, old_key, new_key)
+        driver.warn "WARN: The driver[#{driver.class.name}] config key `#{old_key}` " \
+          "is deprecated, please use `#{new_key}`"
       end
-      default_config :aws_session_token do |driver|
-        ENV['AWS_SESSION_TOKEN'] || ENV['AWS_TOKEN']
+
+      # TODO: remove these in the next major version of TK
+      deprecated_configs = [:ebs_volume_size, :ebs_delete_on_termination, :ebs_device_name]
+      deprecated_configs.each do |d|
+        validations[d] = lambda do |attr, val, driver|
+          unless val.nil?
+            validation_warn(driver, attr, "block_device_mappings")
+          end
+        end
       end
-      default_config :aws_ssh_key_id do |driver|
-        ENV['AWS_SSH_KEY_ID']
+      validations[:ssh_key] = lambda do |attr, val, driver|
+        unless val.nil?
+          validation_warn(driver, attr, "transport.ssh_key")
+        end
       end
-      default_config :image_id do |driver|
-        driver.default_ami
+      validations[:ssh_timeout] = lambda do |attr, val, driver|
+        unless val.nil?
+          validation_warn(driver, attr, "transport.connection_timeout")
+        end
       end
-      default_config :username do |driver|
-        driver.default_username
+      validations[:ssh_retries] = lambda do |attr, val, driver|
+        unless val.nil?
+          validation_warn(driver, attr, "transport.connection_retries")
+        end
       end
-      default_config :endpoint do |driver|
-        "https://ec2.#{driver[:region]}.amazonaws.com/"
+      validations[:username] = lambda do |attr, val, driver|
+        unless val.nil?
+          validation_warn(driver, attr, "transport.username")
+        end
+      end
+      validations[:flavor_id] = lambda do |attr, val, driver|
+        unless val.nil?
+          validation_warn(driver, attr, "instance_type")
+        end
       end
 
-      default_config :interface, nil
+      default_config :block_device_mappings, nil
+      validations[:block_device_mappings] = lambda do |_attr, val, _driver|
+        unless val.nil?
+          val.each do |bdm|
+            unless bdm.keys.include?(:ebs_volume_size) &&
+                bdm.keys.include?(:ebs_delete_on_termination) &&
+                bdm.keys.include?(:ebs_device_name)
+              raise "Every :block_device_mapping must include the keys :ebs_volume_size, " \
+                ":ebs_delete_on_termination and :ebs_device_name"
+            end
+          end
+        end
+      end
 
-      required_config :aws_access_key_id
-      required_config :aws_secret_access_key
-      required_config :aws_ssh_key_id
-      required_config :image_id
+      # The access key/secret are now using the priority list AWS uses
+      # Providing these inside the .kitchen.yml is no longer recommended
+      validations[:aws_access_key_id] = lambda do |attr, val, driver|
+        unless val.nil?
+          driver.warn "WARN: #{attr} has been deprecated, please use " \
+            "ENV['AWS_ACCESS_KEY_ID'] or ~/.aws/credentials.  See " \
+            "the README for more details"
+        end
+      end
+      validations[:aws_secret_access_key] = lambda do |attr, val, driver|
+        unless val.nil?
+          driver.warn "WARN: #{attr} has been deprecated, please use " \
+            "ENV['AWS_SECRET_ACCESS_KEY'] or ~/.aws/credentials.  See " \
+            "the README for more details"
+        end
+      end
+      validations[:aws_session_token] = lambda do |attr, val, driver|
+        unless val.nil?
+          driver.warn "WARN: #{attr} has been deprecated, please use " \
+            "ENV['AWS_SESSION_TOKEN'] or ~/.aws/credentials.  See " \
+            "the README for more details"
+        end
+      end
 
-      def create(state)
-        server = create_server
-        state[:server_id] = server.id
+      # A lifecycle method that should be invoked when the object is about
+      # ready to be used. A reference to an Instance is required as
+      # configuration dependant data may be access through an Instance. This
+      # also acts as a hook point where the object may wish to perform other
+      # last minute checks, validations, or configuration expansions.
+      #
+      # @param instance [Instance] an associated instance
+      # @return [self] itself, for use in chaining
+      # @raise [ClientError] if instance parameter is nil
+      def finalize_config!(instance)
+        super
 
+        if config[:availability_zone].nil?
+          config[:availability_zone] = config[:region] + "b"
+        end
+        # TODO: when we get rid of flavor_id, move this to a default
+        if config[:instance_type].nil?
+          config[:instance_type] = config[:flavor_id] || "m1.small"
+        end
+
+        self
+      end
+
+      def create(state) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        copy_deprecated_configs(state)
+        return if state[:server_id]
+
+        info(Kitchen::Util.outdent!(<<-END))
+          Creating <#{state[:server_id]}>...
+          If you are not using an account that qualifies under the AWS
+          free-tier, you may be charged to run these suites. The charge
+          should be minimal, but neither Test Kitchen nor its maintainers
+          are responsible for your incurred costs.
+        END
+
+        if config[:price]
+          # Spot instance when a price is set
+          server = submit_spot(state)
+        else
+          # On-demand instance
+          server = submit_server
+        end
+        info("Instance <#{server.id}> requested.")
+        tag_server(server)
+
+        state[:server_id] = server.id
         info("EC2 instance <#{state[:server_id]}> created.")
-        server.wait_for { print '.'; ready? }
-        print '(server ready)'
+        wait_log = proc do |attempts|
+          c = attempts * config[:retryable_sleep]
+          t = config[:retryable_tries] * config[:retryable_sleep]
+          info "Waited #{c}/#{t}s for instance <#{state[:server_id]}> to become ready."
+        end
+        server = server.wait_until(
+          :max_attempts => config[:retryable_tries],
+          :delay => config[:retryable_sleep],
+          :before_attempt => wait_log
+        ) do |s|
+          hostname = hostname(s)
+          # Euca instances often report ready before they have an IP
+          s.state.name == "running" && !hostname.nil? && hostname != "0.0.0.0"
+        end
+
+        info("EC2 instance <#{state[:server_id]}> ready.")
         state[:hostname] = hostname(server)
-        wait_for_sshd(state[:hostname], config[:username])
-        print '(ssh ready)\n'
+        instance.transport.connection(state).wait_until_ready
+        create_ec2_json(state)
         debug("ec2:create '#{state[:hostname]}'")
-      rescue Fog::Errors::Error, Excon::Errors::Error => ex
-        raise ActionFailed, ex.message
       end
 
       def destroy(state)
         return if state[:server_id].nil?
 
-        server = connection.servers.get(state[:server_id])
-        server.destroy unless server.nil?
+        server = ec2.get_instance(state[:server_id])
+        unless server.nil?
+          instance.transport.connection(state).close
+          server.terminate unless server.nil?
+        end
+        if state[:spot_request_id]
+          debug("Deleting spot request <#{state[:server_id]}>")
+          ec2.client.cancel_spot_instance_requests(
+            :spot_instance_request_ids => [state[:spot_request_id]]
+          )
+        end
         info("EC2 instance <#{state[:server_id]}> destroyed.")
         state.delete(:server_id)
         state.delete(:hostname)
       end
 
       def default_ami
-        region = amis['regions'][config[:region]]
+        region = amis["regions"][config[:region]]
         region && region[instance.platform.name]
       end
 
-      def default_username
-        amis['usernames'][instance.platform.name] || 'root'
-      end
-
       private
 
-      def connection
-        Fog::Compute.new(
-          :provider               => :aws,
-          :aws_access_key_id      => config[:aws_access_key_id],
-          :aws_secret_access_key  => config[:aws_secret_access_key],
-          :aws_session_token      => config[:aws_session_token],
-          :region                 => config[:region],
-          :endpoint               => config[:endpoint],
+      def ec2
+        @ec2 ||= Aws::Client.new(
+          config[:region],
+          config[:shared_credentials_profile],
+          config[:aws_access_key_id],
+          config[:aws_secret_access_key],
+          config[:aws_session_token]
         )
       end
 
-      def create_server
-        debug_server_config
+      def instance_generator
+        @instance_generator ||= Aws::InstanceGenerator.new(config, ec2)
+      end
 
-        connection.servers.create(
-          :availability_zone  => config[:availability_zone],
-          :security_group_ids => config[:security_group_ids],
-          :tags               => config[:tags],
-          :flavor_id          => config[:flavor_id],
-          :ebs_optimized      => config[:ebs_optimized],
-          :image_id           => config[:image_id],
-          :key_name           => config[:aws_ssh_key_id],
-          :subnet_id          => config[:subnet_id],
-        )
+      # This copies transport config from the current config object into the
+      # state.  This relies on logic in the transport that merges the transport
+      # config with the current state object, so its a bad coupling.  But we
+      # can get rid of this when we get rid of these deprecated configs!
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def copy_deprecated_configs(state)
+        if config[:ssh_timeout]
+          state[:connection_timeout] = config[:ssh_timeout]
+        end
+        if config[:ssh_retries]
+          state[:connection_retries] = config[:ssh_retries]
+        end
+        if config[:username]
+          state[:username] = config[:username]
+        elsif instance.transport[:username] == instance.transport.class.defaults[:username]
+          # If the transport has the default username, copy it from amis.json
+          # This duplicated old behavior but I hate amis.json
+          ami_username = amis["usernames"][instance.platform.name]
+          state[:username] = ami_username if ami_username
+        end
+        if config[:ssh_key]
+          state[:ssh_key] = config[:ssh_key]
+        end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def debug_server_config
-        debug("ec2:region '#{config[:region]}'")
-        debug("ec2:availability_zone '#{config[:availability_zone]}'")
-        debug("ec2:flavor_id '#{config[:flavor_id]}'")
-        debug("ec2:ebs_optimized '#{config[:ebs_optimized]}'")
-        debug("ec2:image_id '#{config[:image_id]}'")
-        debug("ec2:security_group_ids '#{config[:security_group_ids]}'")
-        debug("ec2:tags '#{config[:tags]}'")
-        debug("ec2:key_name '#{config[:aws_ssh_key_id]}'")
-        debug("ec2:subnet_id '#{config[:subnet_id]}'")
+      # Fog AWS helper for creating the instance
+      def submit_server
+        debug("Creating EC2 Instance..")
+        instance_data = instance_generator.ec2_instance_data
+        instance_data[:min_count] = 1
+        instance_data[:max_count] = 1
+        ec2.create_instance(instance_data)
+      end
+
+      def submit_spot(state) # rubocop:disable Metrics/AbcSize
+        debug("Creating EC2 Spot Instance..")
+        request_data = {}
+        request_data[:spot_price] = config[:price].to_s
+        request_data[:launch_specification] = instance_generator.ec2_instance_data
+
+        response = ec2.client.request_spot_instances(request_data)
+        spot_request_id = response[:spot_instance_requests][0][:spot_instance_request_id]
+        # deleting the instance cancels the request, but deleting the request
+        # does not affect the instance
+        state[:spot_request_id] = spot_request_id
+        ec2.client.wait_until(
+          :spot_instance_request_fulfilled,
+          :spot_instance_request_ids => [spot_request_id]
+        ) do |w|
+          w.max_attempts = config[:retryable_tries]
+          w.delay = config[:retryable_sleep]
+          w.before_attempt do |attempts|
+            c = attempts * config[:retryable_sleep]
+            t = config[:retryable_tries] * config[:retryable_sleep]
+            info "Waited #{c}/#{t}s for spot request <#{spot_request_id}> to become fulfilled."
+          end
+        end
+        ec2.get_instance_from_spot_request(spot_request_id)
+      end
+
+      def tag_server(server)
+        tags = []
+        config[:tags].each do |k, v|
+          tags << { :key => k, :value => v }
+        end
+        server.create_tags(:tags => tags)
       end
 
       def amis
         @amis ||= begin
           json_file = File.join(File.dirname(__FILE__),
-            %w{.. .. .. data amis.json})
+            %w[.. .. .. data amis.json])
           JSON.load(IO.read(json_file))
         end
       end
 
-      def interface_types
+      #
+      # Ordered mapping from config name to Fog name.  Ordered by preference
+      # when looking up hostname.
+      #
+      INTERFACE_TYPES =
         {
-          'dns' => 'dns_name',
-          'public' => 'public_ip_address',
-          'private' => 'private_ip_address'
+          "dns" => "public_dns_name",
+          "public" => "public_ip_address",
+          "private" => "private_ip_address"
         }
-      end
 
-      def hostname(server)
-        if config[:interface]
-          method = interface_types.fetch(config[:interface]) do
-            raise Kitchen::UserError, 'Invalid interface'
+      #
+      # Lookup hostname of provided server.  If interface_type is provided use
+      # that interface to lookup hostname.  Otherwise, try ordered list of
+      # options.
+      #
+      def hostname(server, interface_type = nil)
+        if interface_type
+          interface_type = INTERFACE_TYPES.fetch(interface_type) do
+            raise Kitchen::UserError, "Invalid interface [#{interface_type}]"
           end
-          server.send(method)
+          server.send(interface_type)
         else
-          server.dns_name || server.public_ip_address || server.private_ip_address
+          potential_hostname = nil
+          INTERFACE_TYPES.values.each do |type|
+            potential_hostname ||= server.send(type)
+          end
+          potential_hostname
         end
       end
+
+      def create_ec2_json(state)
+        instance.transport.connection(state).execute(
+          "sudo mkdir -p /etc/chef/ohai/hints;sudo touch /etc/chef/ohai/hints/ec2.json"
+        )
+      end
+
     end
   end
 end