kitchen-ec2 0.10.0 → 1.0.0.beta.1

data/lib/kitchen/driver/aws/standard_platform/fedora.rb

@@ -0,0 +1,34 @@
+require "kitchen/driver/aws/standard_platform"
+
+module Kitchen
+  module Driver
+    class Aws
+      class StandardPlatform
+        # https://docs.fedoraproject.org/en-US/Fedora_Draft_Documentation/0.1/html/Cloud_Guide/ch02.html#id697643
+        class Fedora < StandardPlatform
+          StandardPlatform.platforms["fedora"] = self
+
+          def username
+            "fedora"
+          end
+
+          def image_search
+            search = {
+              "owner-id" => "125523088429",
+              "name" => version ? "Fedora-Cloud-Base-#{version}-*" : "Fedora-Cloud-Base-*"
+            }
+            search["architecture"] = architecture if architecture
+            search
+          end
+
+          def self.from_image(driver, image)
+            if image.name =~ /fedora/i
+              image.name =~ /\b(\d+(\.\d+)?)\b/i
+              new(driver, "fedora", (Regexp.last_match || [])[1], image.architecture)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/driver/aws/standard_platform/freebsd.rb

@@ -0,0 +1,37 @@
+require "kitchen/driver/aws/standard_platform"
+
+module Kitchen
+  module Driver
+    class Aws
+      class StandardPlatform
+        # http://www.daemonology.net/freebsd-on-ec2/
+        class Freebsd < StandardPlatform
+          StandardPlatform.platforms["freebsd"] = self
+
+          def username
+            (version && version.to_f < 9.1) ? "root" : "ec2-user"
+          end
+
+          def sudo_command
+          end
+
+          def image_search
+            search = {
+              "owner-id" => "118940168514",
+              "name" => ["FreeBSD #{version}*-RELEASE*", "FreeBSD/EC2 #{version}*-RELEASE*"]
+            }
+            search["architecture"] = architecture if architecture
+            search
+          end
+
+          def self.from_image(driver, image)
+            if image.name =~ /freebsd/i
+              image.name =~ /\b(\d+(\.\d+)?)\b/i
+              new(driver, "freebsd", (Regexp.last_match || [])[1], image.architecture)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/driver/aws/standard_platform/rhel.rb

@@ -0,0 +1,40 @@
+require "kitchen/driver/aws/standard_platform"
+
+module Kitchen
+  module Driver
+    class Aws
+      class StandardPlatform
+        # https://aws.amazon.com/blogs/aws/now-available-red-hat-enterprise-linux-64-amis/
+        class El < StandardPlatform
+          StandardPlatform.platforms["rhel"] = self
+          StandardPlatform.platforms["el"] = self
+
+          def initialize(driver, _name, version, architecture)
+            # rhel = el
+            super(driver, "rhel", version, architecture)
+          end
+
+          def username
+            (version && version.to_f < 6.4) ? "root" : "ec2-user"
+          end
+
+          def image_search
+            search = {
+              "owner-id" => "309956199498",
+              "name" => "RHEL-#{version}*"
+            }
+            search["architecture"] = architecture if architecture
+            search
+          end
+
+          def self.from_image(driver, image)
+            if image.name =~ /rhel/i
+              image.name =~ /\b(\d+(\.\d+)?)/i
+              new(driver, "rhel", (Regexp.last_match || [])[1], image.architecture)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/driver/aws/standard_platform/ubuntu.rb

@@ -0,0 +1,34 @@
+require "kitchen/driver/aws/standard_platform"
+
+module Kitchen
+  module Driver
+    class Aws
+      class StandardPlatform
+        # https://help.ubuntu.com/community/EC2StartersGuide#Official_Ubuntu_Cloud_Guest_Amazon_Machine_Images_.28AMIs.29
+        class Ubuntu < StandardPlatform
+          StandardPlatform.platforms["ubuntu"] = self
+
+          def username
+            "ubuntu"
+          end
+
+          def image_search
+            search = {
+              "owner-id" => "099720109477",
+              "name" => "ubuntu/images/*/ubuntu-*-#{version}*"
+            }
+            search["architecture"] = architecture if architecture
+            search
+          end
+
+          def self.from_image(driver, image)
+            if image.name =~ /ubuntu/i
+              image.name =~ /\b(\d+(\.\d+)?)\b/i
+              new(driver, "ubuntu", (Regexp.last_match || [])[1], image.architecture)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/driver/aws/standard_platform/windows.rb

@@ -0,0 +1,138 @@
+require "kitchen/driver/aws/standard_platform"
+
+module Kitchen
+  module Driver
+    class Aws
+      class StandardPlatform
+        # http://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/finding-an-ami.html
+        class Windows < StandardPlatform
+          StandardPlatform.platforms["windows"] = self
+
+          def username
+            "administrator"
+          end
+
+          # Figure out the right set of names to search for:
+          #
+          # "windows" -> [nil, nil, nil]
+          #   Windows_Server-*-R*_RTM-, Windows_Server-*-R*_SP*-,
+          #   Windows_Server-*-RTM-, Windows_Server-*-SP*-
+          # "windows-2012" -> [2012, 0, nil]
+          #   Windows_Server-2012-RTM-, Windows_Server-2012-SP*-
+          # "windows-2012r2" -> [2012, 2, nil]
+          #   Windows_Server-2012-R2_RTM-, Windows_Server-2012-R2_SP*-
+          # "windows-2012sp1" -> [2012, 0, 1]
+          #   Windows_Server-2012-SP1-
+          # "windows-2012rtm" -> [2012, 0, 0]
+          #   Windows_Server-2012-RTM-
+          # "windows-2012r2sp1" -> [2012, 2, 1]
+          #   Windows_Server-2012-R2_SP1-
+          # "windows-2012r2rtm" -> [2012, 2, 0]
+          #   Windows_Server-2012-R2_RTM-
+          def image_search
+            search = {
+              "owner-alias" => "amazon",
+              "name" => windows_name_filter
+            }
+            search["architecture"] = architecture if architecture
+            search
+          end
+
+          def sort_by_version(images)
+            # 2008r2rtm -> [ img1, img2, img3 ]
+            # 2012r2sp1 -> [ img4, img5 ]
+            # ...
+            images.group_by { |image| self.class.from_image(driver, image).windows_version_parts }.
+              sort_by { |version, _platform_images| version }.
+              reverse.map { |_version, platform_images| platform_images }.flatten(1)
+          end
+
+          def self.from_image(driver, image)
+            if image.name =~ /Windows/i
+              # 2008 R2 SP2
+              if image.name =~ /(\b\d+)\W*(r\d+)?/i
+                major, revision = (Regexp.last_match || [])[1], (Regexp.last_match || [])[2]
+                if image.name =~ /(sp\d+|rtm)/i
+                  service_pack = (Regexp.last_match || [])[1]
+                end
+                revision = revision.downcase if revision
+                service_pack ||= "rtm"
+                service_pack = service_pack.downcase
+                version = "#{major}#{revision}#{service_pack}"
+              end
+
+              new(driver, "windows", version, image.architecture)
+            end
+          end
+
+          protected
+
+          # Turn windows version into [ major, revision, service_pack ]
+          #
+          # nil -> [ nil, nil, nil ]
+          # 2012 -> [ 2012, 0, nil ]
+          # 2012r2 -> [ 2012, 2, nil ]
+          # 2012r2sp4 -> [ 2012, 2, 4 ]
+          # 2012sp4 -> [ 2012, 0, 4 ]
+          # 2012rtm -> [ 2012, 0, 0 ]
+          def windows_version_parts
+            version = self.version
+            if version
+              # windows-server-* -> windows-*
+              if version.split("-", 2)[0] == "server"
+                version = version.split("-", 2)[1]
+              end
+
+              if version =~ /^(\d+)(r\d+)?(sp\d+|rtm)?$/i
+                major, revision, service_pack = Regexp.last_match[1..3]
+              end
+            end
+
+            if major
+              # Get major as an integer (2008 -> 2008, 7 -> 7)
+              major = major.to_i
+
+              # Get revision as an integer (no revision -> 0, R1 -> 1).
+              revision = revision ? revision[1..-1].to_i : 0
+
+              # Turn service_pack into an integer. rtm = 0, spN = N.
+              if service_pack
+                service_pack = (service_pack.downcase == "rtm") ? 0 : service_pack[2..-1].to_i
+              end
+            end
+
+            [major, revision, service_pack]
+          end
+
+          private
+
+          def windows_name_filter
+            major, revision, service_pack = windows_version_parts
+
+            case revision
+            when nil
+              revision_strings = ["", "R*_"]
+            when 0
+              revision_strings = [""]
+            else
+              revision_strings = ["R#{revision}_"]
+            end
+
+            case service_pack
+            when nil
+              revision_strings = revision_strings.flat_map { |r| ["#{r}RTM", "#{r}SP*"] }
+            when 0
+              revision_strings = revision_strings.map { |r| "#{r}RTM" }
+            else
+              revision_strings = revision_strings.map { |r| "#{r}SP#{service_pack}" }
+            end
+
+            revision_strings.map do |r|
+              "Windows_Server-#{major || "*"}-#{r}-English-*-Base-*"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/driver/ec2.rb

@@ -22,7 +22,16 @@ require "kitchen"
 require_relative "ec2_version"
 require_relative "aws/client"
 require_relative "aws/instance_generator"
+require_relative "aws/standard_platform"
+require_relative "aws/standard_platform/centos"
+require_relative "aws/standard_platform/debian"
+require_relative "aws/standard_platform/rhel"
+require_relative "aws/standard_platform/fedora"
+require_relative "aws/standard_platform/freebsd"
+require_relative "aws/standard_platform/ubuntu"
+require_relative "aws/standard_platform/windows"
 require "aws-sdk-core/waiters/errors"
+require "retryable"
 
 module Kitchen
 
@@ -40,8 +49,9 @@ module Kitchen
       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 :instance_type do |driver|
+        driver.default_instance_type
+      end
       default_config :ebs_optimized,      false
       default_config :security_group_ids, nil
       default_config :tags,                "created-by" => "test-kitchen"
@@ -62,120 +72,87 @@ module Kitchen
       default_config :image_id do |driver|
         driver.default_ami
       end
-      default_config :username,            nil
+      default_config :image_search,       nil
+      default_config :username,           nil
       default_config :associate_public_ip, nil
       default_config :interface,           nil
       default_config :http_proxy,          ENV["HTTPS_PROXY"] || ENV["HTTP_PROXY"]
+      default_config :retry_limit,         3
 
       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
 
-      # TODO: remove these in the next major version of TK
+      def self.validation_error(driver, old_key, new_key)
+        raise "ERROR: The driver[#{driver.class.name}] config key `#{old_key}` " \
+          "has been removed, please use `#{new_key}`"
+      end
+
+      # TODO: remove these in 1.1
       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")
+            validation_error(driver, attr, "block_device_mappings")
           end
         end
       end
       validations[:ssh_key] = lambda do |attr, val, driver|
         unless val.nil?
-          validation_warn(driver, attr, "transport.ssh_key")
+          validation_error(driver, attr, "transport.ssh_key")
         end
       end
       validations[:ssh_timeout] = lambda do |attr, val, driver|
         unless val.nil?
-          validation_warn(driver, attr, "transport.connection_timeout")
+          validation_error(driver, attr, "transport.connection_timeout")
         end
       end
       validations[:ssh_retries] = lambda do |attr, val, driver|
         unless val.nil?
-          validation_warn(driver, attr, "transport.connection_retries")
+          validation_error(driver, attr, "transport.connection_retries")
         end
       end
       validations[:username] = lambda do |attr, val, driver|
         unless val.nil?
-          validation_warn(driver, attr, "transport.username")
+          validation_error(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 :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
+          validation_error(driver, attr, "instance_type")
         end
       end
 
       # 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|
+      validations[:aws_access_key_id] = lambda do |attr, val, _driver|
         unless val.nil?
-          driver.warn "WARN: #{attr} has been deprecated, please use " \
+          raise "#{attr} is no longer valid, 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|
+      validations[:aws_secret_access_key] = lambda do |attr, val, _driver|
         unless val.nil?
-          driver.warn "WARN: #{attr} has been deprecated, please use " \
+          raise "#{attr} is no longer valid, 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|
+      validations[:aws_session_token] = lambda do |attr, val, _driver|
         unless val.nil?
-          driver.warn "WARN: #{attr} has been deprecated, please use " \
+          raise "#{attr} is no longer valid, please use " \
             "ENV['AWS_SESSION_TOKEN'] or ~/.aws/credentials.  See " \
             "the README for more details"
         end
       end
 
-      # 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"
-        elsif config[:availability_zone] =~ /^[a-z]$/
-          config[:availability_zone] = config[:region] + config[:availability_zone]
-        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]
+        update_username(state)
 
         info(Kitchen::Util.outdent!(<<-END))
           If you are not using an account that qualifies under the AWS
@@ -192,15 +169,28 @@ module Kitchen
           server = submit_server
         end
         info("Instance <#{server.id}> requested.")
-        ec2.client.wait_until(
-          :instance_exists,
-          :instance_ids => [server.id]
-        )
-        tag_server(server)
+        server.wait_until_exists do |w|
+          w.before_attempt do |attempts|
+            info("Polling AWS for existence, attempt #{attempts}...")
+          end
+        end
 
-        state[:server_id] = server.id
-        info("EC2 instance <#{state[:server_id]}> created.")
-        wait_until_ready(server, state)
+        # See https://github.com/aws/aws-sdk-ruby/issues/859
+        # Tagging can fail with a NotFound error even though we waited until the server exists
+        # Waiting can also fail, so we have to also retry on that.  If it means we re-tag the
+        # instance, so be it.
+        Retryable.retryable(
+          :tries => 10,
+          :sleep => lambda { |n| [2**n, 30].min },
+          :on => ::Aws::EC2::Errors::InvalidInstanceIDNotFound
+        ) do |r, _|
+          info("Attempting to tag the instance, #{r} retries")
+          tag_server(server)
+
+          state[:server_id] = server.id
+          info("EC2 instance <#{state[:server_id]}> created.")
+          wait_until_ready(server, state)
+        end
 
         if windows_os? &&
             instance.transport[:username] =~ /administrator/i &&
@@ -236,9 +226,68 @@ module Kitchen
         state.delete(:hostname)
       end
 
+      def image
+        return @image if defined?(@image)
+
+        if config[:image_id]
+          @image = ec2.resource.image(config[:image_id])
+          show_chosen_image
+
+        else
+          raise "Neither image_id nor an image_search specified for instance #{instance.name}!" \
+                " Please specify one or the other."
+        end
+
+        @image
+      end
+
+      def default_instance_type
+        @instance_type ||= begin
+          # We default to the free tier (t2.micro for hvm, t1.micro for paravirtual)
+          if image && image.virtualization_type == "hvm"
+            info("instance_type not specified. Using free tier t2.micro instance ...")
+            "t2.micro"
+          else
+            info("instance_type not specified. Using free tier t1.micro instance since" \
+                 " image is paravirtual (pick an hvm image to use the superior t2.micro!) ...")
+            "t1.micro"
+          end
+        end
+      end
+
+      # The actual platform is the platform detected from the image
+      def actual_platform
+        @actual_platform ||= Aws::StandardPlatform.from_image(self, image) if image
+      end
+
+      def desired_platform
+        @desired_platform ||= begin
+          platform = Aws::StandardPlatform.from_platform_string(self, instance.platform.name)
+          if platform
+            debug("platform name #{instance.platform.name} appears to be a standard platform." \
+                  " Searching for #{platform} ...")
+          end
+          platform
+        end
+      end
+
       def default_ami
-        region = amis["regions"][config[:region]]
-        region && region[instance.platform.name]
+        @default_ami ||= begin
+          search_platform = desired_platform ||
+            Aws::StandardPlatform.from_platform_string(self, "ubuntu")
+          image_search = config[:image_search] || search_platform.image_search
+          search_platform.find_image(image_search)
+        end
+      end
+
+      def update_username(state)
+        # TODO: if the user explicitly specified the transport's default username,
+        # do NOT overwrite it!
+        if instance.transport[:username] == instance.transport.class.defaults[:username]
+          debug("No SSH username specified: using default username #{actual_platform.username} " \
+                " for image #{config[:image_id]}, which we detected as #{actual_platform}.")
+          state[:username] = actual_platform.username
+        end
       end
 
       def ec2
@@ -248,7 +297,8 @@ module Kitchen
           config[:aws_access_key_id],
           config[:aws_secret_access_key],
           config[:aws_session_token],
-          config[:http_proxy]
+          config[:http_proxy],
+          config[:retry_limit]
         )
       end
 
@@ -256,36 +306,13 @@ module Kitchen
         @instance_generator ||= Aws::InstanceGenerator.new(config, ec2, instance.logger)
       end
 
-      # 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
-
       # Fog AWS helper for creating the instance
       def submit_server
-        debug("Creating EC2 Instance..")
         instance_data = instance_generator.ec2_instance_data
+        debug("Creating EC2 instance in region #{config[:region]} with properties:")
+        instance_data.each do |key, value|
+          debug("- #{key} = #{value.inspect}")
+        end
         instance_data[:min_count] = 1
         instance_data[:max_count] = 1
         ec2.create_instance(instance_data)
@@ -325,6 +352,8 @@ module Kitchen
         server.create_tags(:tags => tags)
       end
 
+      # Normally we could use `server.wait_until_running` but we actually need
+      # to check more than just the instance state
       def wait_until_ready(server, state)
         wait_with_destroy(server, state, "to become ready") do |aws_instance|
           hostname = hostname(aws_instance, config[:interface])
@@ -347,21 +376,8 @@ module Kitchen
         end
       end
 
-      # rubocop:disable Lint/UnusedBlockArgument
-      def fetch_windows_admin_password(server, state)
-        wait_with_destroy(server, state, "to fetch windows admin password") do |aws_instance|
-          enc = server.client.get_password_data(
-            :instance_id => state[:server_id]
-          ).password_data
-          # Password data is blank until password is available
-          !enc.nil? && !enc.empty?
-        end
-        pass = server.decrypt_windows_password(instance.transport[:ssh_key])
-        state[:password] = pass
-        info("Retrieved Windows password for instance <#{state[:server_id]}>.")
-      end
-      # rubocop:enable Lint/UnusedBlockArgument
-
+      # Poll a block, waiting for it to return true.  If it does not succeed
+      # within the configured time we destroy the instance to save people money
       def wait_with_destroy(server, state, status_msg, &block)
         wait_log = proc do |attempts|
           c = attempts * config[:retryable_sleep]
@@ -383,13 +399,20 @@ module Kitchen
         end
       end
 
-      def amis
-        @amis ||= begin
-          json_file = File.join(File.dirname(__FILE__),
-            %w[.. .. .. data amis.json])
-          JSON.load(IO.read(json_file))
+      # rubocop:disable Lint/UnusedBlockArgument
+      def fetch_windows_admin_password(server, state)
+        wait_with_destroy(server, state, "to fetch windows admin password") do |aws_instance|
+          enc = server.client.get_password_data(
+            :instance_id => state[:server_id]
+          ).password_data
+          # Password data is blank until password is available
+          !enc.nil? && !enc.empty?
         end
+        pass = server.decrypt_windows_password(File.expand_path(instance.transport[:ssh_key]))
+        state[:password] = pass
+        info("Retrieved Windows password for instance <#{state[:server_id]}>.")
       end
+      # rubocop:enable Lint/UnusedBlockArgument
 
       #
       # Ordered mapping from config name to Fog name.  Ordered by preference
@@ -424,16 +447,24 @@ module Kitchen
         end
       end
 
+      #
+      # Returns the sudo command to use or empty string if sudo is not configured
+      #
+      def sudo_command
+        instance.provisioner[:sudo] ? instance.provisioner[:sudo_command].to_s : ""
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/LineLength
       def create_ec2_json(state)
         if windows_os?
           cmd = "New-Item -Force C:\\chef\\ohai\\hints\\ec2.json -ItemType File"
         else
-          cmd = "sudo mkdir -p /etc/chef/ohai/hints;sudo touch /etc/chef/ohai/hints/ec2.json"
+          debug "Using sudo_command='#{sudo_command}' for ohai hints"
+          cmd = "#{sudo_command} mkdir -p /etc/chef/ohai/hints; #{sudo_command} touch /etc/chef/ohai/hints/ec2.json"
         end
         instance.transport.connection(state).execute(cmd)
       end
 
-      # rubocop:disable Metrics/MethodLength, Metrics/LineLength
       def default_windows_user_data
         # Preparing custom static admin user if we defined something other than Administrator
         custom_admin_script = ""
@@ -476,6 +507,29 @@ module Kitchen
       end
       # rubocop:enable Metrics/MethodLength, Metrics/LineLength
 
+      def show_chosen_image
+        # Print some debug stuff
+        debug("Image for #{instance.name}: #{image.name}. #{image_info(image)}")
+        if actual_platform
+          info("Detected platform: #{actual_platform.name} version #{actual_platform.version}" \
+               " on #{actual_platform.architecture}. Instance Type: #{config[:instance_type]}." \
+               " Default username: #{actual_platform.username} (default).")
+        else
+          debug("No platform detected for #{image.name}.")
+        end
+      end
+
+      def image_info(image)
+        root_device = image.block_device_mappings.
+          find { |b| b.device_name == image.root_device_name }
+        volume_type = " #{root_device.ebs.volume_type}" if root_device && root_device.ebs
+
+        " Architecture: #{image.architecture}," \
+        " Virtualization: #{image.virtualization_type}," \
+        " Storage: #{image.root_device_type}#{volume_type}," \
+        " Created: #{image.creation_date}"
+      end
+
     end
   end
 end