Refactoring some code into discrete classes so the Ec2 class isn't so giant

Author: tyler-ball

lib/kitchen/driver/ec2.rb

@@ -21,7 +21,8 @@
 require "aws"
 require "kitchen"
 require "kitchen/driver/ec2_version"
-require_relative "client/ec2_client"
+require_relative "ec2/client"
+require_relative "ec2/instance_generator"
 
 module Kitchen
 
@@ -52,9 +53,7 @@ class Ec2 < Kitchen::Driver::Base # rubocop:disable Metrics/ClassLength
       default_config :retryable_sleep,    5
       default_config :aws_access_key_id,  nil
       default_config :aws_secret_access_key, nil
-      default_config :aws_ssh_key_id do |_driver|
-        ENV["AWS_SSH_KEY_ID"]
-      end
+      default_config :aws_ssh_key_id,     ENV["AWS_SSH_KEY_ID"]
       default_config :image_id do |driver|
         driver.default_ami
       end
@@ -230,14 +229,18 @@ def default_ami
       private
 
       def ec2
-        @ec2 ||= Client::Ec2Client.new(
+        @ec2 ||= Client.new(
           config[:region],
           config[:shared_credentials_profile],
           config[:aws_access_key_id],
           config[:aws_secret_access_key]
         )
       end
 
+      def instance_generator
+        @instance_generator ||= InstanceGenerator.new(config, ec2)
+      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
@@ -267,7 +270,7 @@ def copy_deprecated_configs(state)
       # Fog AWS helper for creating the instance
       def submit_server
         debug("Creating EC2 Instance..")
-        instance_data = ec2_instance_data
+        instance_data = instance_generator.ec2_instance_data
         instance_data[:min_count] = 1
         instance_data[:max_count] = 1
         ec2.create_instance(instance_data)
@@ -277,7 +280,7 @@ 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] = ec2_instance_data
+        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]
@@ -302,35 +305,7 @@ def tag_server(server)
         server.create_tags({:tags => tags})
       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
-        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
+
 
       def amis
         @amis ||= begin
@@ -371,73 +346,6 @@ def hostname(server, interface_type = nil)
         end
       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.nil? || 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
-            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],
-              :volume_type           => bdm[:ebs_volume_type],
-              :delete_on_termination => bdm[:ebs_delete_on_termination]
-            },
-            :device_name             => bdm[:ebs_device_name]
-          }
-          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
-        @user_data ||= unless config[:user_data].nil?
-          if File.file?(config[:user_data])
-            config[:user_data] = File.read(config[:user_data])
-          end
-        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"

lib/kitchen/driver/client/ec2_client.rb lib/kitchen/driver/ec2/client.rb

@@ -22,12 +22,12 @@ module Kitchen
 
   module Driver
 
-    module Client
+    class Ec2 < Kitchen::Driver::Base
 
       # A class for creating and managing the EC2 client connection
       #
       # @author Tyler Ball <[email protected]>
-      class Ec2Client
+      class Client
 
         def initialize(region, profile_name = nil, access_key_id = nil, secret_access_key = nil)
           Aws.config = {
@@ -37,10 +37,14 @@ def initialize(region, profile_name = nil, access_key_id = nil, secret_access_ke
         end
 
         # Try and get the credentials from an ordered list of locations
+        # http://docs.aws.amazon.com/sdkforruby/api/index.html#Configuration
         def get_credentials(profile_name, access_key_id, secret_access_key)
           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)
+          # 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?

lib/kitchen/driver/ec2/instance_generator.rb

@@ -0,0 +1,142 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Tyler Ball (<[email protected]>)
+#
+# 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 Ec2 < Kitchen::Driver::Base
+
+      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
+          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.nil? || 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
+              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],
+                :volume_type           => bdm[:ebs_volume_type],
+                :delete_on_termination => bdm[:ebs_delete_on_termination]
+              },
+              :device_name             => bdm[:ebs_device_name]
+            }
+            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
+          @user_data ||= unless config[:user_data].nil?
+            if File.file?(config[:user_data])
+              config[:user_data] = File.read(config[:user_data])
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end