ec2launcher 1.4.3 → 1.5.0

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.5.0
+
+* Initial support for Provisioned IOPS for EBS volumes.
+
 ## 1.4.3
 
 * Fixed typo when deleting snapshots.

data/lib/ec2launcher.rb

@@ -175,7 +175,6 @@ module EC2Launcher
       missing_security_groups = []
       security_groups.each do |sg_name|
         missing_security_groups << sg_name unless sg_map.has_key?(sg_name)
-        puts sg_name
         security_group_ids << sg_map[sg_name].security_group_id
       end
 
@@ -280,6 +279,7 @@ module EC2Launcher
       gems = []
       gems += @environment.gems unless @environment.gems.nil?
       gems += @application.gems unless @application.gems.nil?
+      gems << "ec2launcher"
 
       ##############################
       # Packages - preinstall
@@ -340,9 +340,11 @@ module EC2Launcher
           if block_device_mappings[key] =~ /^ephemeral/
               @log.info "  Block device   : #{key}, #{block_device_mappings[key]}"
           else
-              @log.info "  Block device   : #{key}, #{block_device_mappings[key][:volume_size]}GB, " +
-                 "#{block_device_mappings[key][:snapshot_id]}, " +
-                 "(#{block_device_mappings[key][:delete_on_termination] ? 'auto-delete' : 'no delete'})"
+              block_device_text = "  Block device   : #{key}, #{block_device_mappings[key][:volume_size]}GB, "
+              block_device_text += "#{block_device_mappings[key][:snapshot_id]}" if block_device_mappings[key][:snapshot_id]
+              block_device_text += ", (#{block_device_mappings[key][:delete_on_termination] ? 'auto-delete' : 'no delete'}), "
+              block_device_text += "(#{block_device_mappings[key][:iops].nil? ? 'standard' : block_device_mappings[key][:iops].to_s} IOPS)"
+              @log.info block_device_text
           end
         end
       end
@@ -352,10 +354,35 @@ module EC2Launcher
         exit 3
       end
 
+      # Launch options
+      launch_options = {
+        :ami => ami.ami_id,
+        :availability_zone => availability_zone,
+        :aws_keyfile => aws_keyfile,
+        :block_device_mappings => block_device_mappings,
+        :chef_validation_pem_url => chef_validation_pem_url,
+        :email_notifications => email_notifications,
+        :environment => @environment.name,
+        :gems => gems, 
+        :iam_profile => iam_profile,
+        :instance_type => instance_type,
+        :key => key_name,
+        :packages => packages,
+        :provisioned_iops => @application.has_provisioned_iops?(),
+        :roles => roles, 
+        :security_group_ids => security_group_ids,
+        :subnet => subnet
+      }
+
       # Quit if we're only displaying the defaults
       if @options.show_defaults || @options.show_user_data
         if @options.show_user_data
-          user_data = build_launch_command(fqdn_names[0], short_hostnames[0], roles, chef_validation_pem_url, aws_keyfile, gems, packages, email_notifications)
+          user_data = build_launch_command(
+            launch_options.merge({
+              :fqdn => fqdn_names[0],
+              :short_name => short_hostnames[0]
+            })
+          )
           @log.info ""
           @log.info "---user-data---"
           @log.info user_data
@@ -371,9 +398,14 @@ module EC2Launcher
       instances = []
       fqdn_names.each_index do |i|
         block_device_tags = block_device_builder.generate_device_tags(fqdn_names[i], short_hostnames[i], @environment.name, @application.block_devices)
-        user_data = build_launch_command(fqdn_names[i], short_hostnames[i], roles, chef_validation_pem_url, aws_keyfile, gems, packages, email_notifications)
-
-        instance = launch_instance(fqdn_names[i], short_hostnames[i], ami.ami_id, availability_zone, key_name, security_group_ids, iam_profile, instance_type, user_data, block_device_mappings, block_device_tags, subnet)
+        launch_options.merge!({
+          :fqdn => fqdn_names[i],
+          :short_name => short_hostnames[i],
+          :block_device_tags => block_device_tags,
+        })
+        user_data = build_launch_command(launch_options)
+
+        instance = launch_instance(launch_options, user_data)
         instances << instance
 
         public_dns_name = get_instance_dns(instance, true)
@@ -513,37 +545,58 @@ module EC2Launcher
 
     # Launches an EC2 instance.
     #
-    # @param [String] FQDN for the new host.
-    # @param [String] ami_id id for the AMI to use.
-    # @param [String] availability_zone EC2 availability zone to use
-    # @param [String] key_name EC2 SSH key to use.
-    # @param [Array<String>] security_group_ids list of security groups ids
-    # @param [String, nil] iam_profile The name or ARN of an IAM instance profile. May be nil.
-    # @param [String] instance_type EC2 instance type.
-    # @param [String] user_data command data to store pass to the instance in the EC2 user-data field.
-    # @param [Hash<String,Hash<String, String>, nil] block_device_mappings mapping of device names to block device details. 
-    #        See http://docs.amazonwebservices.com/AWSRubySDK/latest/AWS/EC2/InstanceCollection.html#create-instance_method.
-    # @param [Hash<String,Hash<String, String>>, nil] block_device_tags mapping of device names to hash objects with tags for the new EBS block devices.
+    # launch_options = {
+    #   :ami
+    #   :availability_zone
+    #   :aws_keyfile
+    #   :block_device_mappings
+    #   :block_device_tags
+    #   :chef_validation_pem_url
+    #   :email_notifications
+    #   :fqdn
+    #   :gems
+    #   :iam_profile
+    #   :instance_type
+    #   :key
+    #   :packages
+    #   :roles
+    #   :security_group_ids
+    #   :short_name
+    #   :subnet
+    # }
     #
     # @return [AWS::EC2::Instance] newly created EC2 instance or nil if the launch failed.
-    def launch_instance(hostname, short_hostname, ami_id, availability_zone, key_name, security_group_ids, iam_profile, instance_type, user_data, block_device_mappings = nil, block_device_tags = nil, vpc_subnet = nil)
-      @log.warn "Launching instance... #{hostname}"
+    def launch_instance(launch_options, user_data)
+      @log.warn "Launching instance... #{launch_options[:fqdn]}"
       new_instance = nil
       run_with_backoff(30, 1, "launching instance") do
         launch_mapping = {
-            :image_id => ami_id,
-            :availability_zone => availability_zone,
-            :key_name => key_name,
-            :security_group_ids => security_group_ids,
+            :image_id => launch_options[:ami],
+            :availability_zone => launch_options[:availability_zone],
+            :key_name => launch_options[:key],
+            :security_group_ids => launch_options[:security_group_ids],
             :user_data => user_data,
-            :instance_type => instance_type
+            :instance_type => launch_options[:instance_type]
         }
-        unless block_device_mappings.nil? || block_device_mappings.keys.empty?
-          launch_mapping[:block_device_mappings] = block_device_mappings
+        unless launch_options[:block_device_mappings].nil? || launch_options[:block_device_mappings].keys.empty?
+          if launch_options[:provisioned_iops]
+            # Only include ephemeral devices if we're using provisioned IOPS for the EBS volumes
+            launch_mapping[:block_device_mappings] = {}
+            launch_options[:block_device_mappings].keys.sort.each do |block_device_name|
+              if block_device_name =~ /^ephemeral/
+                launch_mapping[:block_device_mappings][block_device_name] = launch_options[:block_device_mappings][block_device_name]
+              end
+            end
+          else
+            launch_mapping[:block_device_mappings] = launch_options[:block_device_mappings]
+          end
+
+          # Remove the block_device_mappings entry if it's empty. Otherwise the AWS API will throw an error.
+          launch_mapping.delete(:block_device_mappings) if launch_mapping[:block_device_mappings].keys.empty?
         end
 
-        launch_mapping[:iam_instance_profile] = iam_profile if iam_profile
-        launch_mapping[:subnet] = vpc_subnet if vpc_subnet
+        launch_mapping[:iam_instance_profile] = launch_options[:iam_profile] if launch_options[:iam_profile]
+        launch_mapping[:subnet] = launch_options[:vpc_subnet] if launch_options[:vpc_subnet]
 
         new_instance = @ec2.instances.create(launch_mapping)
       end
@@ -568,21 +621,24 @@ module EC2Launcher
       ##############################
       # Tag instance
       @log.info "Tagging instance..."
-      run_with_backoff(30, 1, "tag #{new_instance.id}, tag: name, value: #{hostname}") { new_instance.add_tag("Name", :value => hostname) }
-      run_with_backoff(30, 1, "tag #{new_instance.id}, tag: short_name, value: #{short_hostname}") { new_instance.add_tag("short_name", :value => short_hostname) }
+      run_with_backoff(30, 1, "tag #{new_instance.id}, tag: name, value: #{launch_options[:fqdn]}") { new_instance.add_tag("Name", :value => launch_options[:fqdn]) }
+      run_with_backoff(30, 1, "tag #{new_instance.id}, tag: short_name, value: #{launch_options[:short_name]}") { new_instance.add_tag("short_name", :value => launch_options[:short_name]) }
       run_with_backoff(30, 1, "tag #{new_instance.id}, tag: environment, value: #{@environment.name}") { new_instance.add_tag("environment", :value => @environment.name) }
       run_with_backoff(30, 1, "tag #{new_instance.id}, tag: application, value: #{@application.name}") { new_instance.add_tag("application", :value => @application.name) }
+      if @options.clone_host
+        run_with_backoff(30, 1, "tag #{new_instance.id}, tag: cloned_from, value: #{@options.clone_host}") { new_instance.add_tag("cloned_from", :value => @options.clone_host) }
+      end
 
       ##############################
       # Tag volumes
-      unless block_device_tags.empty?
+      unless launch_options[:provisioned_iops] || launch_options[:block_device_tags].empty?
         @log.info "Tagging volumes..."
         AWS.start_memoizing
-        block_device_tags.keys.each do |device|
+        launch_options[:block_device_tags].keys.each do |device|
           v = new_instance.block_device_mappings[device].volume
-          block_device_tags[device].keys.each do |tag_name|
-            run_with_backoff(30, 1, "tag #{v.id}, tag: #{tag_name}, value: #{block_device_tags[device][tag_name]}") do
-              v.add_tag(tag_name, :value => block_device_tags[device][tag_name])
+          launch_options[:block_device_tags][device].keys.each do |tag_name|
+            run_with_backoff(30, 1, "tag #{v.id}, tag: #{tag_name}, value: #{launch_options[:block_device_tags][device][tag_name]}") do
+              v.add_tag(tag_name, :value => launch_options[:block_device_tags][device][tag_name])
             end
           end
         end
@@ -592,8 +648,8 @@ module EC2Launcher
       ##############################
       # Add to Route53
       if @route53
-        @log.info "Adding A record to Route53: #{hostname} => #{new_instance.private_ip_address}"
-        @route53.create_record(hostname, new_instance.private_ip_address, 'A')
+        @log.info "Adding A record to Route53: #{launch_options[:fqdn]} => #{new_instance.private_ip_address}"
+        @route53.create_record(launch_options[:fqdn], new_instance.private_ip_address, 'A')
       end
 
       new_instance
@@ -628,26 +684,42 @@ module EC2Launcher
 
     # Builds the launch scripts that should run on the new instance.
     #
-    # @param [String] fqdn Fully qualified hostname
-    # @param [String] short_name Short hostname without the domain
-    # @param [String] chef_validation_pem_url URL For the Chef validation pem file
-    # @param [String] aws_keyfile Name of the AWS key to use
-    # @param [Array<String>] gems List of gems to pre-install
-    # @param [Array<String>] packages List of packages to pre-install
-    # @param [EC2Launcher::DSL::EmailNotifications] email_notifications Email notification settings for launch updates
+    # launch_options = {
+    #   :ami
+    #   :availability_zone
+    #   :aws_keyfile
+    #   :block_device_mappings
+    #   :block_device_tags
+    #   :chef_validation_pem_url
+    #   :email_notifications
+    #   :fqdn
+    #   :gems
+    #   :iam_profile
+    #   :instance_type
+    #   :key
+    #   :packages
+    #   :roles
+    #   :security_group_ids
+    #   :short_name
+    #   :subnet
+    # }
     #
     # @return [String] Launch commands to pass into new instance as userdata
-    def build_launch_command(fqdn, short_hostname, roles, chef_validation_pem_url, aws_keyfile, gems, packages, email_notifications)
+    def build_launch_command(launch_options)
       # Build JSON for setup scripts
+
+      # Require ec2launcher gem if cloning and using provisioned IOPS
       setup_json = {
-        'hostname' => fqdn,
-        'short_hostname' => short_hostname,
-        'roles' => roles,
+        'hostname' => launch_options[:fqdn],
+        'short_hostname' => launch_options[:short_name],
+        'block_device_mappings' => launch_options[:block_device_mappings],
+        'roles' => launch_options[:roles],
         'chef_server_url' => @environment.chef_server_url,
-        'chef_validation_pem_url' => chef_validation_pem_url,
-        'aws_keyfile' => aws_keyfile,
-        'gems' => gems,
-        'packages' => packages
+        'chef_validation_pem_url' => launch_options[:chef_validation_pem_url],
+        'aws_keyfile' => launch_options[:aws_keyfile],
+        'gems' => launch_options[:gems],
+        'packages' => launch_options[:packages],
+        'provisioned_iops' => false
       }
       setup_json["gem_path"] = @instance_paths.gem_path
       setup_json["ruby_path"] = @instance_paths.ruby_path
@@ -656,9 +728,16 @@ module EC2Launcher
 
       unless @application.block_devices.nil? || @application.block_devices.empty?
         setup_json['block_devices'] = @application.block_devices
+
+        @application.block_devices.each do |bd|
+          if bd.provisioned_iops?
+            setup_json['provisioned_iops'] = true
+            break
+          end
+        end
       end
-      unless email_notifications.nil?
-        setup_json['email_notifications'] = email_notifications
+      unless launch_options[:email_notifications].nil?
+        setup_json['email_notifications'] = launch_options[:email_notifications]
       end
 
       ##############################
@@ -711,7 +790,9 @@ EOF
         user_data += "\nchmod +x /tmp/setup.rb"
         # user_data += "\nrm -f /tmp/setup.rb.gz.base64"
 
-        user_data += "\n#{setup_json['ruby_path']} /tmp/setup.rb -e #{@environment.name} -a #{@application.name} -h #{fqdn} /tmp/setup.json"
+        user_data += "\ngem install ec2launcher --no-ri --no-rdoc"
+
+        user_data += "\n#{setup_json['ruby_path']} /tmp/setup.rb -e #{@environment.name} -a #{@application.name} -h #{launch_options[:fqdn]} /tmp/setup.json"
         user_data += " -c #{@options.clone_host}" unless @options.clone_host.nil?
         user_data += " 2>&1 > /var/log/cloud-startup.log"
       end

data/lib/ec2launcher/backoff_runner.rb

@@ -35,5 +35,24 @@ module EC2Launcher
       true
     end
 
+    # Runs a block that returns true or false. If the block returns
+    # false, retries the request after sleeping. Repeated failures
+    # trigger an exponential backoff in sleep time.
+    #
+    # @return [Boolean] True if the request suceeded, False otherwise.
+    #
+    def test_with_backoff(max_time, sleep_time, message, &block)
+      if sleep_time < max_time
+        result = block.call
+        unless result
+          puts "Retrying #{message} in #{sleep_time} seconds"
+          sleep sleep_time
+          result = test_with_backoff(max_time, sleep_time * 2, message, &block)
+        end
+        result
+      else
+        false
+      end
+    end
   end
 end

data/lib/ec2launcher/block_device_builder.rb

@@ -118,8 +118,10 @@ module EC2Launcher
 
           block_device_mappings["/dev/#{device_name}"] = {
             :volume_size => volume_size,
-            :delete_on_termination => true
+            :delete_on_termination => block_device.iops.nil?
           }
+
+          block_device_mappings["/dev/#{device_name}"][:iops] = block_device.iops if block_device.iops
         end
       end
     end

data/lib/ec2launcher/dsl/application.rb

@@ -141,6 +141,19 @@ module EC2Launcher
 				end
 			end
 
+			def has_provisioned_iops?()
+				return false unless @block_devices
+
+				provisioned_iops = false
+				@block_devices.each do |bd|
+	        if bd.provisioned_iops?
+	          provisioned_iops = true
+	          break
+	        end
+				end
+				provisioned_iops
+			end
+
 			# IAM profile role name to use for new instances.
 			#
 			# Expects one param in the form of either:

data/lib/ec2launcher/dsl/block_device.rb

@@ -2,6 +2,7 @@
 # Copyright (c) 2012 Sean Laurent
 #
 require 'ec2launcher/dsl/helper'
+require 'json'
 
 module EC2Launcher
 	module DSL
@@ -16,26 +17,56 @@ module EC2Launcher
 			dsl_accessor :owner
 			dsl_accessor :raid_level
 			dsl_accessor :size
+			dsl_accessor :iops
 
-			def initialize()
-				@count = 1
-				@group = "root"
-				@user = "root"
+			def initialize(option_hash = nil)
+				if option_hash
+					@name = option_hash["name"]
+					@count = option_hash["count"]
+					@size = option_hash["size"]
+					@iops = option_hash["iops"]
+					@raid_level = option_hash["raid_level"]
+					@mount = option_hash["mount_point"]
+					@owner = option_hash["owner"]
+					@group = option_hash["group"]
+				end
+
+				# Default values
+				@count ||= 1
+				@group ||= "root"
+				@user ||= "root"
 			end
 
 			def is_raid?()
 				@raid_level.nil?
 			end
 
-			def to_json(*a)
+			def provisioned_iops?()
+				! @iops.nil? || @iops == 0
+			end
+
+			def as_json(*)
 				{
-					"name" => @name,
-					"count" => @count,
-					"raid_level" => @raid_level,
-					"mount_point" => @mount,
-					"owner" => @owner,
-					"group" => @group
-				}.to_json(*a)
+					JSON.create_id => self.class.name,
+					"data" => {
+						"name" => @name,
+						"count" => @count,
+						"size" => @size,
+						"iops" => @iops,
+						"raid_level" => @raid_level,
+						"mount_point" => @mount,
+						"owner" => @owner,
+						"group" => @group
+					}
+				}
+			end
+
+			def to_json(*a)
+				as_json.to_json(*a)
+			end
+
+			def self.json_create(o)
+				new(o['data'])
 			end
 		end
 	end

data/lib/ec2launcher/terminator.rb

@@ -78,9 +78,19 @@ module EC2Launcher
         aws_route53 = AWS::Route53.new if @environment.route53_zone_id
         route53 = EC2Launcher::Route53.new(aws_route53, @environment.route53_zone_id, @log)
 
-        # Remove EBS snapshots
+        ##############################
+        # EBS Volumes
+        ##############################
+        # Find EBS volumes
+        attachments = nil
         AWS.memoize do
-          remove_snapshots(ec2, instance) if snapshot_removal
+          attachments = instance.block_device_mappings.values
+
+          # Remove snapshots
+          remove_snapshots(ec2, attachments) if snapshot_removal
+
+          # Remove volumes, if necessary
+          remove_volumes(ec2, attachments)
         end
 
         private_ip_address = instance.private_ip_address
@@ -104,20 +114,69 @@ module EC2Launcher
       end
     end
 
-    def remove_snapshots(ec2, instance)
-      # Find EBS volumes for instance
-      volumes = instance.block_device_mappings.values
-
+    def remove_snapshots(ec2, attachments)
       # Iterate over over volumes to find snapshots
       @log.info("Searching for snapshots...")
       snapshots = []
-      volumes.each do |vol|
-        volume_snaps = ec2.snapshots.filter("volume-id", vol.volume.id)
+      attachments.each do |attachment|
+        volume_snaps = ec2.snapshots.filter("volume-id", attachment.volume.id)
         volume_snaps.each {|volume_snapshot| snapshots << volume_snapshot }
       end
 
       @log.info("Deleting #{snapshots.size} snapshots...")
-      snapshots.each {|snap| snap.delete }
+      snapshots.each do |snap|
+        run_with_backoff(30, 1, "Deleting snapshot #{snap.id}") do
+          snap.delete
+        end
+      end
+    end
+
+    def remove_volume(ec2, instance, device, volume)
+      @log.info("  Detaching #{volume.id}...")
+      run_with_backoff(30, 1, "detaching #{volume.id}") do
+        volume.detach_from(instance, device)
+      end
+
+      # Wait for volume to fully detach
+      detached = test_with_backoff(120, 1, "waiting for #{volume.id} to detach") do
+        volume.status == :available
+      end
+
+      # Volume failed to detach - do a force detatch instead
+      unless detached
+        @log.info("  Failed to detach #{volume.id}")
+        run_with_backoff(60, 1, "force detaching #{volume.id}") do
+          unless volume.status == :available
+            volume.detach_from(instance, device, {:force => true})
+          end
+        end
+        # Wait for volume to fully detach
+        detached = test_with_backoff(120, 1, "waiting for #{volume.id} to force detach") do
+          volume.status == :available
+        end
+      end
+
+      @log.info("  Deleting volume #{volume.id}")
+      run_with_backoff(30, 1, "delete volume #{volume.id}") do
+        volume.delete
+      end
+    end
+
+    def remove_volumes(ec2, attachments)
+      @log.info("Cleaning up volumes...")
+
+      AWS.memoize do
+        removal_threads = []
+        attachments.each do |attachment|
+          if attachment.exists? && ! attachment.delete_on_termination
+            removal_threads << Thread.new {
+              remove_volume(ec2, attachment.instance, attachment.device, attachment.volume)
+            }
+          end
+        end
+
+        removal_threads.each {|t| t.join }
+      end
     end
   end
 end

data/lib/ec2launcher/version.rb

@@ -2,5 +2,5 @@
 # Copyright (c) 2012 Sean Laurent
 #
 module EC2Launcher
-  VERSION = "1.4.3"
+  VERSION = "1.5.0"
 end

data/startup-scripts/setup.rb

@@ -7,6 +7,8 @@ require 'ostruct'
 
 require 'json'
 
+require 'ec2launcher'
+
 SETUP_SCRIPT = "setup_instance.rb"
 SETUP_SCRIPT_URL = "https://raw.github.com/StudyBlue/ec2launcher/master/startup-scripts//#{SETUP_SCRIPT}"
 

data/startup-scripts/setup_instance.rb

@@ -10,6 +10,8 @@ require 'json'
 
 require 'aws-sdk'
 
+require 'ec2launcher'
+
 AWS_KEYS = "/etc/aws/startup_runner_keys"
 
 class InitOptions
@@ -67,351 +69,435 @@ class InitOptions
 	end
 end
 
-##############################
-# Wrapper that retries failed calls to AWS
-# with an exponential back-off rate.
-def retry_aws_with_backoff(&block)
-	timeout = 1
-	result = nil
-	while timeout < 33 && result.nil?
-		begin
-	  		result = yield
-		rescue AWS::Errors::ServerError
-			puts "Error contacting Amazon. Sleeping #{timeout} seconds."
-			sleep timeout
-			timeout *= 2
-			result = nil
-		end
-	end
-	result
-end
-
-
-# Runs a command and displays the output line by line
-def run_command(cmd)
-  IO.popen(cmd) do |f|
-    while ! f.eof
-      puts f.gets
+class InstanceSetup
+  include EC2Launcher::AWSInitializer
+  include EC2Launcher::BackoffRunner
+
+  def initialize(args)
+    option_parser = InitOptions.new
+    @options = option_parser.parse(args)
+
+    @setup_json_filename = args[0]
+  
+    # Load the AWS access keys
+    properties = {}
+    File.open(AWS_KEYS, 'r') do |file|
+      file.read.each_line do |line|
+        line.strip!
+        if (line[0] != ?# and line[0] != ?=)
+          i = line.index('=')
+          if (i)
+            properties[line[0..i - 1].strip] = line[i + 1..-1].strip
+          else
+            properties[line] = ''
+          end
+        end
+      end
     end
+    @AWS_ACCESS_KEY = properties["AWS_ACCESS_KEY"].gsub('"', '')
+    @AWS_SECRET_ACCESS_KEY = properties["AWS_SECRET_ACCESS_KEY"].gsub('"', '')
+
+    ##############################
+    # Find current instance data
+    @EC2_INSTANCE_TYPE = `wget -T 5 -q -O - http://169.254.169.254/latest/meta-data/instance-type`
+    @AZ = `wget -T 5 -q -O - http://169.254.169.254/latest/meta-data/placement/availability-zone`
+    @INSTANCE_ID = `wget -T 5 -q -O - http://169.254.169.254/latest/meta-data/instance-id`
   end
-  $?
-end
 
-option_parser = InitOptions.new
-options = option_parser.parse(ARGV)
+  def setup()
+    initialize_aws(@AWS_ACCESS_KEY, @AWS_SECRET_ACCESS_KEY)
+
+    # Read the setup JSON file
+    instance_data = JSON.parse(File.read(@setup_json_filename))
+
+    ##############################
+    # EBS VOLUMES
+    ##############################
+    # Create and setup EBS volumes = 
+    setup_ebs_volumes(instance_data) unless instance_data["block_devices"].nil?
+  
+    ##############################
+    # EPHEMERAL VOLUMES
+    ##############################
+    system_arch = `uname -p`.strip
+    default_fs_type = system_arch == "x86_64" ? "xfs" : "ext4"
+
+    #  Process ephemeral devices first
+    ephemeral_drive_count = case EC2_INSTANCE_TYPE
+      when "m1.small" then 1
+      when "m1.medium" then 1
+      when "m2.xlarge" then 1
+      when "m2.2xlarge" then 1
+      when "c1.medium" then 1
+      when "m1.large" then 2
+      when "m2.4xlarge" then 2
+      when "cc1.4xlarge" then 2
+      when "cg1.4xlarge" then 2
+      when "m1.xlarge" then 4
+      when "c1.xlarge" then 4
+      when "cc2.8xlarge" then 4
+      else 0
+    end
 
-setup_json_filename = ARGV[0]
+    # Partition the ephemeral drives
+    partition_list = []
+    build_block_devices(ephemeral_drive_count, "xvdf") do |device_name, index|
+      partition_list << "/dev/#{device_name}"
+    end
+    partition_devices(partition_list)
 
-# Load the AWS access keys
-properties = {}
-File.open(AWS_KEYS, 'r') do |file|
-  file.read.each_line do |line|
-    line.strip!
-    if (line[0] != ?# and line[0] != ?=)
-      i = line.index('=')
-      if (i)
-        properties[line[0..i - 1].strip] = line[i + 1..-1].strip
-      else
-        properties[line] = ''
+    # Format and mount the ephemeral drives
+    build_block_devices(ephemeral_drive_count, "xvdf") do |device_name, index|
+      format_filesystem(system_arch, "/dev/#{device_name}1")
+
+      mount_point = case index
+        when 0 then "/mnt"
+        else "/mnt/extra#{index - 1}"
       end
+      mount_device("/dev/#{device_name}1", mount_point, "root", "root", default_fs_type)
     end
-  end
-end
-AWS_ACCESS_KEY = properties["AWS_ACCESS_KEY"].gsub('"', '')
-AWS_SECRET_ACCESS_KEY = properties["AWS_SECRET_ACCESS_KEY"].gsub('"', '')
-
-##############################
-# Find current instance data
-EC2_INSTANCE_TYPE = `wget -T 5 -q -O - http://169.254.169.254/latest/meta-data/instance-type`
-
-# Read the setup JSON file
-instance_data = JSON.parse(File.read(setup_json_filename))
-
-##############################
-# Block devices
-##############################
-
-# Creates filesystem on a device
-# XFS on 64-bit
-# ext4 on 32-bit
-def format_filesystem(system_arch, device)
-	fs_type = system_arch == "x86_64" ? "XFS" : "ext4"
-	puts "Formatting #{fs_type} filesystem on #{device} ..."
-
-	command = case system_arch
-		when "x86_64" then "/sbin/mkfs.xfs -f #{device}"
-		else "/sbin/mkfs.ext4 -F #{device}"
-	end
-	IO.popen(command) do |f|
-		while ! f.eof
-			puts f.gets
-		end
-	end
-end
 
-# Creates and formats a RAID array, given a
-# list of partitioned devices
-def initialize_raid_array(system_arch, device_list, raid_device = '/dev/md0', raid_type = 0)
-	partitions = device_list.collect {|device| "#{device}1" }
+    ##############################
+    # CHEF SETUP
+    ##############################
 
-	puts "Creating RAID-#{raid_type.to_s} array #{raid_device} ..."
-	command = "/sbin/mdadm --create #{raid_device} --level #{raid_type.to_s} --raid-devices #{partitions.length} #{partitions.join(' ')}"
-	puts command
-	puts `#{command}`
+    # Path to executables
+    chef_path = instance_data["chef_path"]
+    knife_path = instance_data["knife_path"]
 
-	format_filesystem(system_arch, raid_device)
-end
+    ##############################
+    # Create knife configuration
+    knife_config = <<EOF
+log_level                :info
+log_location             STDOUT
+node_name                '#{options.hostname}'
+client_key               '/etc/chef/client.pem'
+validation_client_name   'chef-validator'
+validation_key           '/etc/chef/validation.pem'
+chef_server_url          '#{instance_data["chef_server_url"]}'
+cache_type               'BasicFile'
+cache_options( :path => '/etc/chef/checksums' )
+EOF
+    home_folder = `echo $HOME`.strip
+    `mkdir -p #{home_folder}/.chef && chown 700 #{home_folder}/.chef`
+    File.open("#{home_folder}/.chef/knife.rb", "w") {|f| f.puts knife_config }
+    `chmod 600 #{home_folder}/.chef/knife.rb`
+
+    ##############################
+    # Add roles
+    instance_data["roles"].each do |role|
+      cmd = "#{knife_path} node run_list add #{options.hostname} \"role[#{role}]\""
+      puts cmd
+      puts `#{cmd}`
+    end
 
-# Creates a mount point, mounts the device and adds it to fstab
-def mount_device(device, mount_point, owner, group, fs_type)
-	puts `echo #{device} #{mount_point} #{fs_type} noatime 0 0|tee -a /etc/fstab`
-	puts `mkdir -p #{mount_point}`
-	puts `mount #{mount_point}`
-	puts `chown #{owner}:#{owner} #{mount_point}`
-end
+    result = run_chef_client(chef_path)
+    unless result == 0
+      puts "***** ERROR running chef-client. Relaunching chef-client in 30 seconds."
+      sleep(30)
+      result = run_chef_client(chef_path)
+    end
+    unless result == 0
+      puts "***** ERROR running chef-client. Relaunching chef-client in 30 seconds."
+      sleep(30)
+      result = run_chef_client(chef_path)
+    end
 
-# Partitions a list of mounted EBS volumes
-def partition_devices(device_list)
-	puts "Partioning devices ..."
-	device_list.each do |device|
-		puts "  * #{device}"
-		`echo 0|sfdisk #{device}`
-	end
+    ##############################
+    # EMAIL NOTIFICATION
+    ##############################
+    if instance_data["email_notifications"]
+      # Email notification through SES
+      puts "Email notification through SES..."
+      AWS.config({
+        :access_key_id => instance_data["email_notifications"]["ses_access_key"],
+        :secret_access_key => instance_data["email_notifications"]["ses_secret_key"]
+      })
+      ses = AWS::SimpleEmailService.new
+      ses.send_email(
+        :from => instance_data["email_notifications"]["from"],
+        :to => instance_data["email_notifications"]["to"],
+        :subject => "Server setup complete: #{options.hostname}",
+        :body_text => "Server setup is complete for Host: #{options.hostname}, Environment: #{options.environ}, Application: #{options.application}",
+        :body_html => "<div>Server setup is complete for:</div><div><strong>Host:</strong> #{options.hostname}</div><div><strong>Environment:</strong> #{options.environ}</div><div><strong>Application:</strong> #{options.application}</div>"
+      )
+    else
+      puts "Skipping email notification."
+    end
 
-	puts "Sleeping 10 seconds to reload partition tables ..."
-	sleep 10
-end
+  end
 
-##############################
-# Assembles a set of existing partitions into a RAID array.
-def assemble_raid_array(partition_list, raid_device = '/dev/md0', raid_type = 0)
-  puts "Assembling cloned RAID-#{raid_type.to_s} array #{raid_device} ..."
-  command = "/sbin/mdadm --assemble #{raid_device} #{partition_list.join(' ')}"
-  puts command
-  puts `#{command}`
-end
+  ##############################
+  # Launch Chef
+  def run_chef_client(chef_path)
+    result = 0
+    last_line = nil
+    Open3.popen3(chef_path) do |stdin, stdout, stderr, wait_thr|
+      stdout.each do |line|
+        last_line = line
+        puts line
+      end
+      result = wait_thr.value if wait_thr
+    end
+    if last_line =~ /[ ]ERROR[:][ ]/
+      result = -1
+    end
 
-# Initializes a raid array with existing EBS volumes that are already attached to the instace.
-# Partitions & formats new volumes.
-# Returns the RAID device name.
-def setup_attached_raid_array(system_arch, devices, raid_device = '/dev/md0', raid_type = 0, clone = false)
-	partitions = devices.collect {|device| "#{device}1" }
-
-	unless clone
-		partition_devices(devices)
-		initialize_raid_array(system_arch, devices, raid_device, raid_type)
-	else
-		assemble_raid_array(partitions, raid_device, raid_type)
-	end
-	`echo DEVICE #{partitions.join(' ')} |tee -a /etc/mdadm.conf`
-
-  # RAID device name can be a symlink on occasion, so we
-  # want to de-reference the symlink to keep everything clear.
-  raid_info = "/dev/md0"
-  raid_scan_info = `/sbin/mdadm --detail --scan 2>&1`
-  puts "RAID Scan Info: #{raid_scan_info}"
-  if raid_scan_info =~ /cannot open/
-    # This happens occasionally on CentOS 6:
-    #   $ /sbin/mdadm --detail --scan
-    #   mdadm: cannot open /dev/md/0_0: No such file or directory
-    #   mdadm: cannot open /dev/md/1_0: No such file or directory
-    #
-    # This is tied to how the raid array was created, especially if the array was created with an older version of mdadm. 
-    # See https://bugzilla.redhat.com/show_bug.cgi?id=606481 for a lengthy discussion. We should really be naming RAID 
-    # arrays correctly and using the HOMEHOST setting to re-assemble it.
-    #
-    # As a stop-gap, try to use the specified raid_device name passed into this method.
-    raid_info = raid_device
-
-    # We need to manually retrieve the UUID of the array
-    array_uuid = `mdadm --detail #{raid_device}|grep UUID|awk '// { print $3; }'`.strip
-
-    # We have to manually update mdadm.conf as well
-    #`echo ARRAY #{raid_device} level=raid#{raid_type.to_s} num-devices=#{devices.count.to_s} meta-data=0.90 UUID=#{array_uuid} |tee -a /etc/mdadm.conf`
-    `echo ARRAY #{raid_device} level=raid#{raid_type.to_s} num-devices=#{devices.count.to_s} UUID=#{array_uuid} |tee -a /etc/mdadm.conf`
-  else
-    raid_info = raid_scan_info.split("\n")[-1].split()[1]
+    result
   end
-  raid_device_real_path = Pathname.new(raid_info).realpath.to_s
-  puts "Using raid device: #{raid_info}. Real path: #{raid_device_real_path}"
-	
-  raid_device_real_path
-end
 
-def build_block_devices(count, device = "xvdj", &block)
-  device_name = device
-  0.upto(count - 1).each do |index|
-    yield device_name, index
-    device_name.next!
+  # Runs a command and displays the output line by line
+  def run_command(cmd)
+    IO.popen(cmd) do |f|
+      while ! f.eof
+        puts f.gets
+      end
+    end
+    $?
   end
-end
 
-system_arch = `uname -p`.strip
-default_fs_type = system_arch == "x86_64" ? "xfs" : "ext4"
-
-#  Process ephemeral devices first
-ephemeral_drive_count = case EC2_INSTANCE_TYPE
-	when "m1.small" then 1
-	when "m1.medium" then 1
-	when "m2.xlarge" then 1
-	when "m2.2xlarge" then 1
-	when "c1.medium" then 1
-	when "m1.large" then 2
-	when "m2.4xlarge" then 2
-	when "cc1.4xlarge" then 2
-	when "cg1.4xlarge" then 2
-	when "m1.xlarge" then 4
-	when "c1.xlarge" then 4
-	when "cc2.8xlarge" then 4
-	else 0
-end
+  def attach_volume(instance, device_name, volume)
+    ec2 = AWS::EC2.new
 
-# Partition the ephemeral drives
-partition_list = []
-build_block_devices(ephemeral_drive_count, "xvdf") do |device_name, index|
-	partition_list << "/dev/#{device_name}"
-end
-partition_devices(partition_list)
+    volume_available = test_with_backoff(120, 1, "check EBS volume available #{device_name} (#{volume.id})") do
+      volume.status == :available
+    end
 
-# Format and mount the ephemeral drives
-build_block_devices(ephemeral_drive_count, "xvdf") do |device_name, index|
-	format_filesystem(system_arch, "/dev/#{device_name}1")
+    # TODO: Handle when volume is still not available
 
-	mount_point = case index
-		when 0 then "/mnt"
-		else "/mnt/extra#{index - 1}"
-	end
-	mount_device("/dev/#{device_name}1", mount_point, "root", "root", default_fs_type)
-end
+    # Attach volume
+    attachment = nil
+    run_with_backoff(60, 1, "attaching volume #{volume.id} to #{device_name}") do
+      attachment = volume.attach_to(instance, device_name)
+    end
+    volume_attached = test_with_backoff(60, 1, "check EBS volume attached #{device_name} (#{volume.id})") do
+      attachment.status == :attached
+    end
+
+    # TODO: Handle when volume fails to attach
 
-# Process EBS volumes
-unless instance_data["block_devices"].nil?
-  # Install mdadm if we have any RAID devices
-  raid_required = false
-  instance_data["block_devices"].each do |block_device_json|
-    unless block_device_json["raid_level"].nil?
-      raid_required = true
-      break
+    attachment
+  end
+
+  def setup_ebs_volumes(instance_data)
+    # Install mdadm if we have any RAID devices
+    raid_required = false
+    instance_data["block_devices"].each do |block_device|
+      unless block_device.raid_level.nil?
+        raid_required = true
+        break
+      end
+    end
+    if raid_required
+      result = run_command("yum install mdadm -y")
+      unless result == 0
+        run_command("yum clean all")
+        run_command("yum install mdadm -y")
+      end
+    end
+
+    # Create and attach the EBS volumes, if necessary
+    if instance_data["provisioned_iops"]
+      puts "Setup requires EBS volumes with provisioned IOPS."
+      
+      ec2 = AWS::EC2.new
+      instance = ec2.instances[@INSTANCE_ID]
+
+      volumes = {}
+      block_creation_threads = []
+      instance_data["block_device_mappings"].keys.sort.each do |device_name|
+        block_data = instance_data["block_device_mappings"][device_name]
+        next if block_data =~ /^ephemeral/
+
+        block_info = {}
+        block_info[:availability_zone] = @AZ
+        block_info[:size] = block_data["volume_size"]
+        block_info[:snapshot_id] = block_data["snapshot_id"] if block_data["snapshot_id"]
+        if block_data["iops"]
+          block_info[:iops] = block_data["iops"]
+          block_info[:volume_type] = "io1"
+        end
+
+        # Create volume
+        block_device_text = "Creating EBS volume: #{device_name}, #{block_info[:volume_size]}GB, "
+        block_device_text += "#{block_info[:snapshot_id]}" if block_info[:snapshot_id]
+        block_device_text += "#{block_info[:iops].nil? ? 'standard' : block_info[:iops].to_s} IOPS"
+        puts block_device_text
+        volume = nil
+        run_with_backoff(60, 1, "creating ebs volume") do 
+          volume = ec2.volumes.create(block_info)
+        end
+
+        volumes[device_name] = volume
+
+        block_creation_threads << Thread.new {
+          attach_volume(instance, device_name, volume)
+        }
+      end
+      
+      block_creation_threads.each do |t|
+        t.join
+      end
+
+      AWS.memoize do
+        block_device_builder = EC2Launcher::BlockDeviceBuilder.new(ec2, 60)
+        block_device_tags = block_device_builder.generate_device_tags(instance_data["hostname"], instance_data["short_hostname"], instance_data["environment"], instance_data["block_devices"])
+        unless block_device_tags.empty?
+          puts "Tagging volumes"
+          AWS.memoize do
+            block_device_tags.keys.each do |device_name|
+              volume = volumes[device_name]
+              block_device_tags[device_name].keys.each do |tag_name|
+                run_with_backoff(30, 1, "tag #{volume.id}, tag: #{tag_name}, value: #{block_device_tags[device_name][tag_name]}") do
+                  volume.add_tag(tag_name, :value => block_device_tags[device_name][tag_name])
+                end
+              end
+            end
+          end
+        end
+      end
+    end # provisioned iops
+
+    raid_array_count = 0
+    next_device_name = "xvdj"
+    instance_data["block_devices"].each do |block_device_json|
+      if block_device_json["raid_level"].nil?
+        # If we're not cloning an existing snapshot, then we need to partition and format the drive.
+        if options.clone_host.nil?
+          partition_devices([ "/dev/#{next_device_name}" ])
+          format_filesystem(system_arch, "/dev/#{next_device_name}1")
+        end
+        mount_device("/dev/#{next_device_name}1", block_device_json["mount_point"], block_device_json["owner"], block_device_json["group"], default_fs_type)
+        next_device_name.next!
+      else
+        raid_devices = []
+        build_block_devices(block_device_json["count"], next_device_name) do |device_name, index|
+          raid_devices << "/dev/#{device_name}"
+          next_device_name = device_name
+        end
+        puts "Setting up attached raid array... system_arch = #{system_arch}, raid_devices = #{raid_devices}, device = /dev/md#{(127 - raid_array_count).to_s}"
+        raid_device_name = setup_attached_raid_array(system_arch, raid_devices, "/dev/md#{(127 - raid_array_count).to_s}", block_device_json["raid_level"].to_i, ! options.clone_host.nil?)
+        mount_device(raid_device_name, block_device_json["mount_point"], block_device_json["owner"], block_device_json["group"], default_fs_type)
+        raid_array_count += 1
+      end
     end
   end
-  if raid_required
-    result = run_command("yum install mdadm -y")
-    unless result == 0
-      run_command("yum clean all")
-      run_command("yum install mdadm -y")
+
+  # Creates filesystem on a device
+  # XFS on 64-bit
+  # ext4 on 32-bit
+  def format_filesystem(system_arch, device)
+    fs_type = system_arch == "x86_64" ? "XFS" : "ext4"
+    puts "Formatting #{fs_type} filesystem on #{device} ..."
+
+    command = case system_arch
+      when "x86_64" then "/sbin/mkfs.xfs -f #{device}"
+      else "/sbin/mkfs.ext4 -F #{device}"
+    end
+    IO.popen(command) do |f|
+      while ! f.eof
+        puts f.gets
+      end
     end
   end
 
-  raid_array_count = 0
-	next_device_name = "xvdj"
-	instance_data["block_devices"].each do |block_device_json|
-		if block_device_json["raid_level"].nil?
-			# If we're not cloning an existing snapshot, then we need to partition and format the drive.
-			if options.clone_host.nil?
-				partition_devices([ "/dev/#{next_device_name}" ])
-				format_filesystem(system_arch, "/dev/#{next_device_name}1")
-			end
-			mount_device("/dev/#{next_device_name}1", block_device_json["mount_point"], block_device_json["owner"], block_device_json["group"], default_fs_type)
-			next_device_name.next!
-		else
-			raid_devices = []
-			build_block_devices(block_device_json["count"], next_device_name) do |device_name, index|
-				raid_devices << "/dev/#{device_name}"
-				next_device_name = device_name
-			end
-      puts "Setting up attached raid array... system_arch = #{system_arch}, raid_devices = #{raid_devices}, device = /dev/md#{(127 - raid_array_count).to_s}"
-			raid_device_name = setup_attached_raid_array(system_arch, raid_devices, "/dev/md#{(127 - raid_array_count).to_s}", block_device_json["raid_level"].to_i, ! options.clone_host.nil?)
-			mount_device(raid_device_name, block_device_json["mount_point"], block_device_json["owner"], block_device_json["group"], default_fs_type)
-      raid_array_count += 1
-		end
-	end
-end
+  # Creates and formats a RAID array, given a
+  # list of partitioned devices
+  def initialize_raid_array(system_arch, device_list, raid_device = '/dev/md0', raid_type = 0)
+    partitions = device_list.collect {|device| "#{device}1" }
 
-##############################
-# CHEF SETUP
-##############################
+    puts "Creating RAID-#{raid_type.to_s} array #{raid_device} ..."
+    command = "/sbin/mdadm --create #{raid_device} --level #{raid_type.to_s} --raid-devices #{partitions.length} #{partitions.join(' ')}"
+    puts command
+    puts `#{command}`
 
-# Path to executables
-chef_path = instance_data["chef_path"]
-knife_path = instance_data["knife_path"]
+    format_filesystem(system_arch, raid_device)
+  end
 
-##############################
-# Create knife configuration
-knife_config = <<EOF
-log_level                :info
-log_location             STDOUT
-node_name                '#{options.hostname}'
-client_key               '/etc/chef/client.pem'
-validation_client_name   'chef-validator'
-validation_key           '/etc/chef/validation.pem'
-chef_server_url          '#{instance_data["chef_server_url"]}'
-cache_type               'BasicFile'
-cache_options( :path => '/etc/chef/checksums' )
-EOF
-home_folder = `echo $HOME`.strip
-`mkdir -p #{home_folder}/.chef && chown 700 #{home_folder}/.chef`
-File.open("#{home_folder}/.chef/knife.rb", "w") do |f|
-  f.puts knife_config
-end
-`chmod 600 #{home_folder}/.chef/knife.rb`
-
-##############################
-# Add roles
-instance_data["roles"].each do |role|
-  cmd = "#{knife_path} node run_list add #{options.hostname} \"role[#{role}]\""
-  puts cmd
-  puts `#{cmd}`
-end
+  # Creates a mount point, mounts the device and adds it to fstab
+  def mount_device(device, mount_point, owner, group, fs_type)
+    puts `echo #{device} #{mount_point} #{fs_type} noatime 0 0|tee -a /etc/fstab`
+    puts `mkdir -p #{mount_point}`
+    puts `mount #{mount_point}`
+    puts `chown #{owner}:#{owner} #{mount_point}`
+  end
 
-##############################
-# Launch Chef
-def run_chef_client(chef_path)
-  result = 0
-  last_line = nil
-  Open3.popen3(chef_path) do |stdin, stdout, stderr, wait_thr|
-    stdout.each do |line|
-      last_line = line
-      puts line
+  # Partitions a list of mounted EBS volumes
+  def partition_devices(device_list)
+    puts "Partioning devices ..."
+    device_list.each do |device|
+      puts "  * #{device}"
+      `echo 0|sfdisk #{device}`
     end
-    result = wait_thr.value if wait_thr
+
+    puts "Sleeping 10 seconds to reload partition tables ..."
+    sleep 10
   end
-  if last_line =~ /[ ]ERROR[:][ ]/
-    result = -1
+
+  ##############################
+  # Assembles a set of existing partitions into a RAID array.
+  def assemble_raid_array(partition_list, raid_device = '/dev/md0', raid_type = 0)
+    puts "Assembling cloned RAID-#{raid_type.to_s} array #{raid_device} ..."
+    command = "/sbin/mdadm --assemble #{raid_device} #{partition_list.join(' ')}"
+    puts command
+    puts `#{command}`
   end
 
-  result
-end
+  # Initializes a raid array with existing EBS volumes that are already attached to the instace.
+  # Partitions & formats new volumes.
+  # Returns the RAID device name.
+  def setup_attached_raid_array(system_arch, devices, raid_device = '/dev/md0', raid_type = 0, clone = false)
+    partitions = devices.collect {|device| "#{device}1" }
+
+    unless clone
+      partition_devices(devices)
+      initialize_raid_array(system_arch, devices, raid_device, raid_type)
+    else
+      assemble_raid_array(partitions, raid_device, raid_type)
+    end
+    `echo DEVICE #{partitions.join(' ')} |tee -a /etc/mdadm.conf`
+
+    # RAID device name can be a symlink on occasion, so we
+    # want to de-reference the symlink to keep everything clear.
+    raid_info = "/dev/md0"
+    raid_scan_info = `/sbin/mdadm --detail --scan 2>&1`
+    puts "RAID Scan Info: #{raid_scan_info}"
+    if raid_scan_info =~ /cannot open/
+      # This happens occasionally on CentOS 6:
+      #   $ /sbin/mdadm --detail --scan
+      #   mdadm: cannot open /dev/md/0_0: No such file or directory
+      #   mdadm: cannot open /dev/md/1_0: No such file or directory
+      #
+      # This is tied to how the raid array was created, especially if the array was created with an older version of mdadm. 
+      # See https://bugzilla.redhat.com/show_bug.cgi?id=606481 for a lengthy discussion. We should really be naming RAID 
+      # arrays correctly and using the HOMEHOST setting to re-assemble it.
+      #
+      # As a stop-gap, try to use the specified raid_device name passed into this method.
+      raid_info = raid_device
+
+      # We need to manually retrieve the UUID of the array
+      array_uuid = `mdadm --detail #{raid_device}|grep UUID|awk '// { print $3; }'`.strip
+
+      # We have to manually update mdadm.conf as well
+      #`echo ARRAY #{raid_device} level=raid#{raid_type.to_s} num-devices=#{devices.count.to_s} meta-data=0.90 UUID=#{array_uuid} |tee -a /etc/mdadm.conf`
+      `echo ARRAY #{raid_device} level=raid#{raid_type.to_s} num-devices=#{devices.count.to_s} UUID=#{array_uuid} |tee -a /etc/mdadm.conf`
+    else
+      raid_info = raid_scan_info.split("\n")[-1].split()[1]
+    end
+    raid_device_real_path = Pathname.new(raid_info).realpath.to_s
+    puts "Using raid device: #{raid_info}. Real path: #{raid_device_real_path}"
+    
+    raid_device_real_path
+  end
 
-result = run_chef_client(chef_path)
-unless result == 0
-  puts "***** ERROR running chef-client. Relaunching chef-client in 30 seconds."
-  sleep(30)
-  result = run_chef_client(chef_path)
-end
-unless result == 0
-  puts "***** ERROR running chef-client. Relaunching chef-client in 30 seconds."
-  sleep(30)
-  result = run_chef_client(chef_path)
+  def build_block_devices(count, device = "xvdj", &block)
+    device_name = device
+    0.upto(count - 1).each do |index|
+      yield device_name, index
+      device_name.next!
+    end
+  end
 end
 
-##############################
-# EMAIL NOTIFICATION
-##############################
-if instance_data["email_notifications"]
-  # Email notification through SES
-  puts "Email notification through SES..."
-  AWS.config({
-    :access_key_id => instance_data["email_notifications"]["ses_access_key"],
-    :secret_access_key => instance_data["email_notifications"]["ses_secret_key"]
-  })
-  ses = AWS::SimpleEmailService.new
-  ses.send_email(
-    :from => instance_data["email_notifications"]["from"],
-    :to => instance_data["email_notifications"]["to"],
-    :subject => "Server setup complete: #{options.hostname}",
-    :body_text => "Server setup is complete for Host: #{options.hostname}, Environment: #{options.environ}, Application: #{options.application}",
-    :body_html => "<div>Server setup is complete for:</div><div><strong>Host:</strong> #{options.hostname}</div><div><strong>Environment:</strong> #{options.environ}</div><div><strong>Application:</strong> #{options.application}</div>"
-  )
-else
-  puts "Skipping email notification."
-end
+instance_setup = InstanceSetup.new(ARGV)
+instance_setup.setup()

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ec2launcher
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-28 00:00:00.000000000 Z
+date: 2012-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk