boxgrinder-build 0.9.2 → 0.9.3

data/integ/spec/modular-spec.rb

@@ -0,0 +1,71 @@
+#
+# Copyright 2010 Red Hat, Inc.
+#
+# This is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 3 of
+# the License, or (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this software; if not, write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+
+require 'rubygems'
+require 'boxgrinder-build/appliance'
+require 'boxgrinder-core/models/config'
+require 'boxgrinder-core/helpers/log-helper'
+require 'boxgrinder-build/helpers/guestfs-helper'
+require 'fileutils'
+
+module BoxGrinder
+  describe 'BoxGrinder Build' do
+    before(:all) do
+      # Cleaning up before build
+      FileUtils.rm_rf('build/')
+
+      # Prepare local repository
+      FileUtils.mkdir_p "/tmp/boxgrinder-repo/"
+      FileUtils.cp "#{File.dirname(__FILE__)}/../packages/ephemeral-repo-test-0.1-1.noarch.rpm", "/tmp/boxgrinder-repo/"
+      system "createrepo /tmp/boxgrinder-repo/"
+    end
+
+    after(:all) do
+      # Cleaning up after build
+      FileUtils.rm_rf('build/')
+    end
+
+    before(:each) do
+      # Deliver the packaged appliance to CloudFront
+      @config = Config.new(:delivery => :cloudfront)
+      @log = LogHelper.new(:level => :trace, :type => :stdout)
+    end
+
+    after(:each) do
+      # Make sure all deliverables really exists
+      @appliance.plugin_chain.last[:plugin].deliverables.each_value do |file|
+        File.exists?(file).should == true
+      end
+    end
+
+    context "modular appliances" do
+      it "should build modular appliance based on Fedora and convert it to VirtualBox" do
+        @config.merge!(:platform => :virtualbox)
+        @appliance = Appliance.new("#{File.dirname(__FILE__)}/../appliances/modular.appl", @config, :log => @log).create
+
+        GuestFSHelper.new([@appliance.plugin_chain[1][:plugin].deliverables[:disk]], @appliance.appliance_config, @config, :log => @log ).customize do |guestfs, guestfs_helper|
+          guestfs.exists('/fedora-boxgrinder-test').should == 1
+          guestfs.exists('/common-test-base-boxgrinder-test').should == 1
+          guestfs.exists('/hardware-cpus-boxgrinder-test').should == 1
+          guestfs.exists('/repos-boxgrinder-noarch-ephemeral-boxgrinder-test').should == 1
+        end
+      end
+    end
+  end
+end
+

data/lib/boxgrinder-build/appliance.rb

@@ -28,12 +28,16 @@ require 'boxgrinder-build/managers/plugin-manager'
 
 module BoxGrinder
   class Appliance
+    attr_reader :plugin_chain
+    attr_reader :appliance_config
+
     def initialize(appliance_definition, config = Config.new, options = {})
       @appliance_definition = appliance_definition
       @config = config
       @log = options[:log] || LogHelper.new(:level => @config.log_level)
     end
 
+    # TODO: this is not very clean...
     def read_definition
       # first try to read as appliance definition file
       appliance_helper = ApplianceDefinitionHelper.new(:log => @log)
@@ -59,14 +63,37 @@ module BoxGrinder
     end
 
     def validate_definition
-      raise "No operating system plugins installed. Install one or more operating system plugin. See http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#Operating_system_plugins for more info." if PluginManager.instance.plugins[:os].empty?
-
       os_plugin = PluginManager.instance.plugins[:os][@appliance_config.os.name.to_sym]
 
       raise "Not supported operating system selected: #{@appliance_config.os.name}. Make sure you have installed right operating system plugin, see http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#Operating_system_plugins. Supported OSes are: #{PluginManager.instance.plugins[:os].keys.join(", ")}" if os_plugin.nil?
       raise "Not supported operating system version selected: #{@appliance_config.os.version}. Supported versions are: #{os_plugin[:versions].join(", ")}" unless @appliance_config.os.version.nil? or os_plugin[:versions].include?(@appliance_config.os.version)
     end
 
+    # Here we initialize all required plugins and create a plugin chain.
+    # Initialization involves also plugin configuration validation for specified plugin type.
+    def initialize_plugins
+      @plugin_chain = []
+
+      os_plugin, os_plugin_info = PluginManager.instance.initialize_plugin(:os, @appliance_config.os.name.to_sym)
+      os_plugin.init(@config, @appliance_config, os_plugin_info, :log => @log)
+
+      @plugin_chain << {:plugin => os_plugin, :param => @appliance_definition}
+
+      if platform_selected?
+        platform_plugin, platform_plugin_info = PluginManager.instance.initialize_plugin(:platform, @config.platform)
+        platform_plugin.init(@config, @appliance_config, platform_plugin_info, :log => @log, :previous_plugin => @plugin_chain.last[:plugin])
+
+        @plugin_chain << {:plugin => platform_plugin}
+      end
+
+      if delivery_selected?
+        delivery_plugin, delivery_plugin_info = PluginManager.instance.initialize_plugin(:delivery, @config.delivery)
+        delivery_plugin.init(@config, @appliance_config, delivery_plugin_info, :log => @log, :previous_plugin => @plugin_chain.last[:plugin], :type => @config.delivery)
+
+        @plugin_chain << {:plugin => delivery_plugin}
+      end
+    end
+
     def remove_old_builds
       @log.info "Removing previous builds for #{@appliance_config.name} appliance..."
       FileUtils.rm_rf(@appliance_config.path.build)
@@ -76,72 +103,45 @@ module BoxGrinder
     def execute_plugin_chain
       @log.info "Building '#{@appliance_config.name}' appliance for #{@appliance_config.hardware.arch} architecture."
 
-      execute_delivery_plugin(execute_platform_plugin(execute_os_plugin))
+      @plugin_chain.each { |p| execute_plugin(p[:plugin], p[:param]) }
     end
 
     def create
-      @log.debug "Launching new BoxGrinder build..."
+      @log.debug "Launching new build..."
       @log.trace "Used configuration: #{@config.to_yaml.gsub(/(\S*(key|account|cert|username|host|password)\S*).*:(.*)/, '\1' + ": <REDACTED>")}"
 
+      # Let's load all plugins first
       PluginHelper.new(@config, :log => @log).load_plugins
       read_definition
       validate_definition
-      remove_old_builds if @config.force
-      execute_plugin_chain
-    end
+      initialize_plugins
 
-    def execute_os_plugin
-      raise "No operating system plugins installed. Install one or more operating system plugin. See http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#Operating_system_plugins for more info." if PluginManager.instance.plugins[:os].empty?
-
-      os_plugin, os_plugin_info = PluginManager.instance.initialize_plugin(:os, @appliance_config.os.name.to_sym)
-      os_plugin.init(@config, @appliance_config, :log => @log, :plugin_info => os_plugin_info)
-
-      if os_plugin.deliverables_exists?
-        @log.info "Deliverables for #{os_plugin_info[:name]} operating system plugin exists, skipping."
-        return {:deliverables => os_plugin.deliverables, :plugin_info => os_plugin_info}
-      end
+      remove_old_builds if @config.force
 
-      @log.debug "Executing operating system plugin for #{@appliance_config.os.name}..."
-      os_plugin.run(@appliance_definition)
-      @log.debug "Operating system plugin executed."
+      execute_plugin_chain
 
-      {:deliverables => os_plugin.deliverables, :plugin_info => os_plugin_info}
+      self
     end
 
-    def execute_platform_plugin(previous_plugin_output)
-      if @config.platform == :none or @config.platform.to_s.empty? == nil
-        @log.debug "No platform selected, skipping platform conversion."
-        return previous_plugin_output
-      end
-
-      raise "No platform plugins installed. Install one or more platform plugin. See http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#Platform_plugins for more info." if PluginManager.instance.plugins[:platform].empty?
-
-      platform_plugin, platform_plugin_info = PluginManager.instance.initialize_plugin(:platform, @config.platform)
-      platform_plugin.init(@config, @appliance_config, :log => @log, :plugin_info => platform_plugin_info, :previous_plugin_info => previous_plugin_output[:plugin_info], :previous_deliverables => previous_plugin_output[:deliverables])
-
-      if platform_plugin.deliverables_exists?
-        @log.info "Deliverables for #{platform_plugin_info[:name]} platform plugin exists, skipping."
-        return {:deliverables => platform_plugin.deliverables, :plugin_info => platform_plugin_info}
-      end
-
-      @log.debug "Executing platform plugin for #{@config.platform}..."
-      platform_plugin.run
-      @log.debug "Platform plugin executed."
+    def platform_selected?
+      !(@config.platform == :none or @config.platform.to_s.empty? == nil)
+    end
 
-      {:deliverables => platform_plugin.deliverables, :plugin_info => platform_plugin_info}
+    def delivery_selected?
+      !(@config.delivery == :none or @config.delivery.to_s.empty? == nil)
     end
 
-    def execute_delivery_plugin(previous_plugin_output)
-      if @config.delivery == :none or @config.delivery.to_s.empty? == nil
-        @log.debug "No delivery method selected, skipping delivering."
+    def execute_plugin(plugin, param = nil)
+      if plugin.deliverables_exists?
+        @log.info "Deliverables for #{plugin.plugin_info[:name]} #{plugin.plugin_info[:type]} plugin exists, skipping."
         return
       end
 
-      raise "No delivery plugins installed. Install one or more delivery plugin. See http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#Delivery_plugins for more info" if PluginManager.instance.plugins[:delivery].empty?
+      @log.debug "Executing #{plugin.plugin_info[:type]} plugin for #{@appliance_config.os.name}..."
 
-      delivery_plugin, delivery_plugin_info = PluginManager.instance.initialize_plugin(:delivery, @config.delivery)
-      delivery_plugin.init(@config, @appliance_config, :log => @log, :plugin_info => delivery_plugin_info, :previous_plugin_info => previous_plugin_output[:plugin_info], :previous_deliverables => previous_plugin_output[:deliverables])
-      delivery_plugin.run(@config.delivery)
+      param.nil? ? plugin.run : plugin.run(param)
+
+      @log.debug "Operating system plugin executed."
     end
   end
 end

data/lib/boxgrinder-build/helpers/guestfs-helper.rb

@@ -20,7 +20,9 @@ require 'boxgrinder-build/helpers/augeas-helper'
 require 'boxgrinder-core/helpers/log-helper'
 require 'guestfs'
 require 'rbconfig'
-require 'resolv'
+require 'net/http'
+require 'uri'
+require 'timeout'
 
 module BoxGrinder
   class GuestFSHelper
@@ -36,10 +38,11 @@ module BoxGrinder
     def hw_virtualization_available?
       @log.trace "Checking if HW virtualization is available..."
 
+      ec2 = false
+
       begin
-        ec2 = Resolv.getname("169.254.169.254").include?(".ec2.internal")
-      rescue Resolv::ResolvError
-        ec2 = false
+        Timeout::timeout(2) { ec2 = Net::HTTP.get_response(URI.parse('http://169.254.169.254/latest/meta-data/ami-id')).code.eql?("200") }
+      rescue Exception
       end
 
       if `egrep '^flags.*(vmx|svm)' /proc/cpuinfo | wc -l`.chomp.strip.to_i > 0 and !ec2
@@ -54,13 +57,13 @@ module BoxGrinder
 
     # https://issues.jboss.org/browse/BGBUILD-83
     def log_callback
-      log = Proc.new do |event, event_handle, buf, array|
+      default_callback = Proc.new do |event, event_handle, buf, array|
         buf.chomp!
 
         if event == 64
-          @log.trace "GFS: #{buf}"
-        else
           @log.debug "GFS: #{buf}"
+        else
+          @log.trace "GFS: #{buf}" unless buf.start_with?('recv_from_daemon', 'send_to_daemon')
         end
       end
 
@@ -69,7 +72,7 @@ module BoxGrinder
       # Guestfs::EVENT_TRACE      => 64
 
       # Referencing int instead of constants make it easier to test
-      @guestfs.set_event_callback(log, 16 | 32 | 64)
+      @guestfs.set_event_callback(default_callback, 16 | 32 | 64)
 
       yield if block_given?
     end

data/lib/boxgrinder-build/helpers/plugin-helper.rb

@@ -33,6 +33,7 @@ require 'boxgrinder-build/plugins/platform/virtualbox/virtualbox-plugin'
 require 'boxgrinder-build/plugins/os/centos/centos-plugin'
 require 'boxgrinder-build/plugins/os/rhel/rhel-plugin'
 require 'boxgrinder-build/plugins/os/fedora/fedora-plugin'
+require 'boxgrinder-build/plugins/os/sl/sl-plugin'
 
 module BoxGrinder
   class PluginHelper

data/lib/boxgrinder-build/helpers/qemu.wrapper

@@ -6,7 +6,7 @@ else
   args=( "$@" )
 fi
 
-if [ "`uname -r | grep x86_64 | wc -l`" -eq "1" ]; then
+if [ "`uname -a | grep x86_64 | wc -l`" -eq "1" ]; then
   bin=/usr/bin/qemu-system-x86_64
 else
   bin=/usr/bin/qemu

data/lib/boxgrinder-build/plugins/base-plugin.rb

@@ -29,6 +29,9 @@ require 'logger'
 
 module BoxGrinder
   class BasePlugin
+    attr_reader :plugin_info
+    attr_reader :deliverables
+
     def initialize
       @plugin_config = {}
 
@@ -38,32 +41,74 @@ module BoxGrinder
       @dir = OpenCascade.new
     end
 
-    def init(config, appliance_config, options = {})
+    def init(config, appliance_config, info, options = {})
       @config = config
       @appliance_config = appliance_config
       @options = options
+      @plugin_info = info
+
+      # Optional options :)
+      @type = options[:type] || @plugin_info[:name]
+      @previous_plugin = options[:previous_plugin]
       @log = options[:log] || LogHelper.new
       @exec_helper = options[:exec_helper] || ExecHelper.new(:log => @log)
       @image_helper = options[:image_helper] || ImageHelper.new(@config, @appliance_config, :log => @log)
-      @previous_plugin_info = options[:previous_plugin_info]
-      @previous_deliverables = options[:previous_deliverables] || OpenCascade.new
-
-      @plugin_info = options[:plugin_info]
 
       @dir.base = "#{@appliance_config.path.build}/#{@plugin_info[:name]}-plugin"
       @dir.tmp = "#{@dir.base}/tmp"
 
+      if @previous_plugin
+        @previous_deliverables = @previous_plugin.deliverables
+        @previous_plugin_info = @previous_plugin.plugin_info
+      else
+        @previous_deliverables = OpenCascade.new
+      end
+
+      # TODO get rid of that - we don't have plugin configuration files - everything is now in one place.
       read_plugin_config
       merge_plugin_config
 
+      # Indicate whether deliverables of select plugin should be moved to final destination or not.
+      # TODO Needs some thoughts - if we don't have deliverables that we care about - should they be in @deliverables?
       @move_deliverables = true
+
+      # Validate the plugin configuration.
+      # Please make the validate method as simple as possible, because it'll be executed also in unit tests.
+      validate
+
+      # The plugin is initialized now. We can do some fancy stuff with it.
       @initialized = true
 
+      # If there is something defined in the plugin that should be executed after plugin initialization - it should go 
+      # to after_init method.
       after_init
 
       self
     end
 
+    # This is a stub that should be overriden by the actual plugin implementation.
+    # It can use subtype(:TYPE) calls to validate for a specific type.
+    # KISS!
+    def validate
+    end
+
+    # Callback - executed after initialization.
+    def after_init
+    end
+
+    # Callback - executed after execution.
+    def after_execute
+    end
+
+    # Validation helper method.
+    #
+    # Execute the validation only for selected plugin type.
+    # TODO make this prettier somehow? Maybe moving validation to a class?
+    def subtype(type)
+      return unless @type == type
+      yield if block_given?
+    end
+
     def register_deliverable(deliverable)
       raise "You can only register deliverables after the plugin is initialized, please initialize the plugin using init method." if @initialized.nil?
       raise "Please specify deliverables as Hash, not #{deliverable.class}." unless deliverable.is_a?(Hash)
@@ -120,7 +165,7 @@ module BoxGrinder
       raise "You can only execute the plugin after the plugin is initialized, please initialize the plugin using init method." if @initialized.nil?
     end
 
-    def run(*args)
+    def run(param = nil)
       unless is_supported_os?
         @log.error "#{@plugin_info[:full_name]} plugin supports following operating systems: #{supported_oses}. Your appliance contains #{@appliance_config.os.name} #{@appliance_config.os.version} operating system which is not supported by this plugin, sorry."
         return
@@ -129,7 +174,7 @@ module BoxGrinder
       FileUtils.rm_rf @dir.tmp
       FileUtils.mkdir_p @dir.tmp
 
-      execute(*args)
+      param.nil? ? execute : execute(param)
 
       # TODO execute post commands for platform plugins here?
 
@@ -141,18 +186,14 @@ module BoxGrinder
       FileUtils.rm_rf @dir.tmp
     end
 
-    def after_init
-    end
-
-    def after_execute
-    end
-
     def deliverables_exists?
       raise "You can only check deliverables after the plugin is initialized, please initialize the plugin using init method." if @initialized.nil?
 
+      return false if deliverables.empty?
+
       exists = true
 
-      @target_deliverables.each_value do |file|
+      deliverables.each_value do |file|
         unless File.exists?(file)
           exists = false
           break

data/lib/boxgrinder-build/plugins/delivery/ebs/ebs-plugin.rb

@@ -20,58 +20,105 @@ require 'rubygems'
 require 'boxgrinder-build/plugins/base-plugin'
 require 'AWS'
 require 'open-uri'
+require 'timeout'
+require 'pp'
 
 module BoxGrinder
   class EBSPlugin < BasePlugin
     KERNELS = {
         'eu-west-1' => {
-            'i386' => {:aki => 'aki-4deec439'},
-            'x86_64' => {:aki => 'aki-4feec43b'}
+            :endpoint => 'ec2.eu-west-1.amazonaws.com',
+            :location => 'EU',
+            :kernel => {
+                'i386' => {:aki => 'aki-4deec439'},
+                'x86_64' => {:aki => 'aki-4feec43b'}
+            }
         },
+
         'ap-southeast-1' => {
-            'i386' => {:aki => 'aki-13d5aa41'},
-            'x86_64' => {:aki => 'aki-11d5aa43'}
+            :endpoint => 'ec2.ap-southeast-1.amazonaws.com',
+            :location => 'ap-southeast-1',
+            :kernel => {
+                'i386' => {:aki => 'aki-13d5aa41'},
+                'x86_64' => {:aki => 'aki-11d5aa43'}
+            }
+        },
+
+        'ap-northeast-1' => {
+            :endpoint => 'ec2.ap-northeast-1.amazonaws.com',
+            :location => 'ap-northeast-1',
+            :kernel => {
+                'i386' => {:aki => 'aki-d209a2d3'},
+                'x86_64' => {:aki => 'aki-d409a2d5'}
+            }
+
         },
+
         'us-west-1' => {
-            'i386' => {:aki => 'aki-99a0f1dc'},
-            'x86_64' => {:aki => 'aki-9ba0f1de'}
+            :endpoint => 'ec2.us-west-1.amazonaws.com',
+            :location => 'us-west-1',
+            :kernel => {
+                'i386' => {:aki => 'aki-99a0f1dc'},
+                'x86_64' => {:aki => 'aki-9ba0f1de'}
+            }
         },
+
         'us-east-1' => {
-            'i386' => {:aki => 'aki-407d9529'},
-            'x86_64' => {:aki => 'aki-427d952b'}
+            :endpoint => 'ec2.amazonaws.com',
+            :location => '',
+            :kernel => {
+                'i386' => {:aki => 'aki-407d9529'},
+                'x86_64' => {:aki => 'aki-427d952b'}
+            }
         }
     }
 
-    def after_init
-      if valid_platform?
-        @current_avaibility_zone = open('http://169.254.169.254/latest/meta-data/placement/availability-zone').string
-        @region = @current_avaibility_zone.scan(/((\w+)-(\w+)-(\d+))/).flatten.first
-      end
+    ROOT_DEVICE_NAME = '/dev/sda1'
+    POLL_FREQ = 1 #second
+    TIMEOUT = 1000 #seconds
+    EC2_HOSTNAME_LOOKUP_TIMEOUT = 10
 
-      set_default_config_value('availability_zone', @current_avaibility_zone)
+    def validate
+      raise PluginValidationError, "You are trying to run this plugin on invalid platform. You can run the EBS delivery plugin only on EC2." unless valid_platform?
+
+      @current_availability_zone = get_ec2_availability_zone; @log.trace @current_availability_zone
+
+      set_default_config_value('availability_zone', @current_availability_zone)
       set_default_config_value('delete_on_termination', true)
+      set_default_config_value('overwrite', false)
+      set_default_config_value('snapshot', false)
+      set_default_config_value('preserve_snapshots', false)
+      validate_plugin_config(['access_key', 'secret_access_key', 'account_number'], 'http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#EBS_Delivery_Plugin')
 
-      register_supported_os('fedora', ['13', '14', '15'])
-      register_supported_os('rhel', ['6'])
+      raise PluginValidationError, "You can only convert to EBS type AMI appliances converted to EC2 format. Use '-p ec2' switch. For more info about EC2 plugin see http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#EC2_Platform_Plugin." unless @previous_plugin_info[:name] == :ec2
+      raise PluginValidationError, "You selected #{@plugin_config['availability_zone']} availability zone, but your instance is running in #{@current_availability_zone} zone. Please change availability zone in plugin configuration file to #{@current_availability_zone} (see http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#EBS_Delivery_Plugin) or use another instance in #{@plugin_config['availability_zone']} zone to create your EBS AMI." if @plugin_config['availability_zone'] != @current_availability_zone
     end
 
-    def execute(type = :ebs)
-      validate_plugin_config(['access_key', 'secret_access_key', 'account_number'], 'http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#EBS_Delivery_Plugin')
+    def after_init
+      @region = availability_zone_to_region(@current_availability_zone)
 
-      raise "You try to run this plugin on invalid platform. You can run EBS delivery plugin only on EC2." unless valid_platform?
-      raise "You can only convert to EBS type AMI appliances converted to EC2 format. Use '-p ec2' switch. For more info about EC2 plugin see http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#EC2_Platform_Plugin." unless @previous_plugin_info[:name] == :ec2
-      raise "You selected #{@plugin_config['availability_zone']} avaibility zone, but your instance is running in #{@current_avaibility_zone} zone. Please change avaibility zone in plugin configuration file to #{@current_avaibility_zone} (see http://boxgrinder.org/tutorials/boxgrinder-build-plugins/#EBS_Delivery_Plugin) or use another instance in #{@plugin_config['availability_zone']} zone to create your EBS AMI." if @plugin_config['availability_zone'] != @current_avaibility_zone
+      register_supported_os('fedora', ['13', '14', '15'])
+      register_supported_os('rhel', ['6'])
+      register_supported_os('centos', ['5'])
+    end
 
+    def execute
       ebs_appliance_description = "#{@appliance_config.summary} | Appliance version #{@appliance_config.version}.#{@appliance_config.release} | #{@appliance_config.hardware.arch} architecture"
 
-      @ec2 = AWS::EC2::Base.new(:access_key_id => @plugin_config['access_key'], :secret_access_key => @plugin_config['secret_access_key'])
+      @ec2 = AWS::EC2::Base.new(:access_key_id => @plugin_config['access_key'],
+                                :secret_access_key => @plugin_config['secret_access_key'],
+                                :server => KERNELS[@region][:endpoint]
+      )
 
       @log.debug "Checking if appliance is already registered..."
 
-      ami_id = already_registered?(ebs_appliance_name)
+      ami_info = ami_info(ebs_appliance_name)
 
-      if ami_id
-        @log.warn "EBS AMI '#{ebs_appliance_name}' is already registered as '#{ami_id}' (region: #{@region})."
+      if ami_info and @plugin_config['overwrite']
+        @log.info "Overwrite is enabled. Stomping existing assets"
+        stomp_ebs(ami_info)
+      elsif ami_info
+        @log.warn "EBS AMI '#{ebs_appliance_name}' is already registered as '#{ami_info.imageId}' (region: #{@region})."
         return
       end
 
@@ -81,13 +128,15 @@ module BoxGrinder
 
       @appliance_config.hardware.partitions.each_value { |partition| size += partition['size'] }
 
-      # create_volume with 10GB size
-      volume_id = @ec2.create_volume(:size => size.to_s, :availability_zone => @plugin_config['availability_zone'])['volumeId']
+      # create_volume, ceiling to avoid fractions as per https://issues.jboss.org/browse/BGBUILD-224
+      volume_id = @ec2.create_volume(:size => size.ceil.to_s, :availability_zone => @plugin_config['availability_zone'])['volumeId']
+
+      begin
 
       @log.debug "Volume #{volume_id} created."
       @log.debug "Waiting for EBS volume #{volume_id} to be available..."
 
-      # wait fo volume to be created
+      # wait for volume to be created
       wait_for_volume_status('available', volume_id)
 
       # get first free device to mount the volume
@@ -110,7 +159,9 @@ module BoxGrinder
       # wait for volume to be attached
       wait_for_volume_status('in-use', volume_id)
 
-      sleep 10 # let's wait to discover the attached volume by OS
+      @log.debug "Waiting for the attached EBS volume to be discovered by the OS"
+
+      wait_for_volume_attachment(suffix)  # add rescue block for timeout when no suffix can be found then re-raise
 
       @log.info "Copying data to EBS volume..."
 
@@ -125,7 +176,7 @@ module BoxGrinder
 
       @ec2.detach_volume(:device => "/dev/sd#{suffix}", :volume_id => volume_id, :instance_id => instance_id)
 
-      @log.debug "Waiting for EBS volume to be available..."
+      @log.debug "Waiting for EBS volume to become available..."
 
       wait_for_volume_status('available', volume_id)
 
@@ -167,15 +218,124 @@ module BoxGrinder
                                         :device_name => '/dev/sde',
                                         :virtual_name => 'ephemeral3'
                                     }],
-          :root_device_name => '/dev/sda1',
+          :root_device_name => ROOT_DEVICE_NAME,
           :architecture => @appliance_config.hardware.base_arch,
-          :kernel_id => KERNELS[@region][@appliance_config.hardware.base_arch][:aki],
+          :kernel_id => KERNELS[@region][:kernel][@appliance_config.hardware.base_arch][:aki],
           :name => ebs_appliance_name,
           :description => ebs_appliance_description)['imageId']
 
+      rescue Timeout::Error
+        @log.error "Timed out. Manual intervention may be necessary to complete the task."
+        raise
+      end
+
       @log.info "EBS AMI '#{ebs_appliance_name}' registered: #{image_id} (region: #{@region})"
     end
 
+    def get_volume_info(volume_id)
+      begin
+        @ec2.describe_volumes(:volume_id => volume_id).volumeSet.item.each do |volume|
+          return volume if volume.volumeId == volume_id
+        end
+      rescue AWS::Error, AWS::InvalidVolumeIDNotFound => e# only InvalidVolumeIDNotFound should be returned when no volume found, but is not always doing so at present.
+        @log.trace "Error getting volume info: #{e}"
+        return nil
+      end
+      nil
+    end
+
+    def snapshot_info(snapshot_id)
+     begin
+      @ec2.describe_snapshots(:snapshot_id => snapshot_id).snapshotSet.item.each do |snapshot|
+        return snapshot if snapshot.snapshotId == snapshot_id
+      end
+     rescue AWS::InvalidSnapshotIDNotFound
+       return nil
+     end
+      nil
+    end
+
+    def block_device_from_ami(ami_info, device_name)
+      ami_info.blockDeviceMapping.item.each do |device|
+        return device if device.deviceName == device_name
+      end
+      nil
+    end
+
+    def get_instances(ami_id)
+      #EC2 Gem has yet to be updated with new filters, once the patches have been pulled then :image_id filter will be picked up
+      instances_info = @ec2.describe_instances(:image_id => ami_id).reservationSet
+      instances=[]
+      instances_info["item"].each do
+        |item| item["instancesSet"]["item"].each do |i|
+          instances.push i if i.imageId == ami_id #TODO remove check after gem update
+        end
+      end
+      return instances.uniq unless instances.empty?
+      nil
+    end
+
+    def stomp_ebs(ami_info)
+
+      device = block_device_from_ami(ami_info, ROOT_DEVICE_NAME)
+
+      if device #if there is the anticipated device on the image
+        snapshot_info = snapshot_info(device.ebs.snapshotId)
+        volume_id = snapshot_info.volumeId
+        volume_info = get_volume_info(volume_id)
+
+        @log.trace "Volume info for #{volume_id} : #{PP::pp(volume_info,"")}"
+        @log.info "Finding any existing image with the block store attached"
+
+        if instances = get_instances(ami_info.imageId)
+          raise "There are still instances of #{ami_info.imageId} running, you must stop them: #{instances.collect {|i| i.instanceId}.join(",")}"
+        end
+
+        if volume_info #if the physical volume exists
+          unless volume_info.status == 'available'
+            begin
+             @log.info "Forcibly detaching block store #{volume_info.volumeId}"
+             @ec2.detach_volume(:volume_id => volume_info.volumeId, :force => true)
+            rescue AWS::IncorrectState
+             @log.debug "State of the volume has changed, our data must have been stale. This should not be fatal."
+            end
+          end
+
+          @log.debug "Waiting for volume to become detached"
+          wait_for_volume_status('available', volume_info.volumeId)
+
+          begin
+            @log.info "Deleting block store"
+            @ec2.delete_volume(:volume_id => volume_info.volumeId)
+            @log.debug "Waiting for volume deletion to be confirmed"
+            wait_for_volume_status('deleted', volume_info.volumeId)
+          rescue AWS::InvalidVolumeIDNotFound
+            @log.debug "An external entity has probably deleted the volume just before we tried to. This should not be fatal."
+          end
+        end
+
+        begin
+          @log.debug "Deregistering AMI"
+          @ec2.deregister_image(:image_id => ami_info.imageId)
+        rescue AWS::InvalidAMIIDUnavailable, AWS::InvalidAMIIDNotFound
+          @log.debug "An external entity has already deregistered the AMI just before we tried to. This should not be fatal."
+        end
+
+        if !@plugin_config['preserve_snapshots'] and snapshot_info #if the snapshot exists
+         begin
+          @log.debug "Deleting snapshot #{snapshot_info.snapshotId}"
+          @ec2.delete_snapshot(:snapshot_id => snapshot_info.snapshotId)
+         rescue AWS::InvalidSnapshotIDNotFound
+          @log.debug "An external entity has probably deleted the snapshot just before we tried to. This should not be fatal."
+         end
+        end
+      else
+        @log.error "Expected device #{ROOT_DEVICE_NAME} was not found on the image."
+        return false
+      end
+      true
+    end
+
     def ebs_appliance_name
       base_path = "#{@appliance_config.name}/#{@appliance_config.os.name}/#{@appliance_config.os.version}/#{@appliance_config.version}.#{@appliance_config.release}"
 
@@ -186,17 +346,26 @@ module BoxGrinder
       while already_registered?("#{base_path}-SNAPSHOT-#{snapshot}/#{@appliance_config.hardware.arch}")
         snapshot += 1
       end
+      # Reuse the last key (if there was one)
+      snapshot -=1 if snapshot > 1 and @plugin_config['overwrite']
 
       "#{base_path}-SNAPSHOT-#{snapshot}/#{@appliance_config.hardware.arch}"
     end
 
-    def already_registered?(name)
-      images = @ec2.describe_images(:owner_id => @plugin_config['account_number'].to_s.gsub(/-/, ''))
-
-      return false if images.nil? or images['imagesSet'].nil?
+    def ami_info(name)
+      images = @ec2.describe_images(:owner_id => @plugin_config['account_number'].to_s.gsub(/-/,''))
+      return false if images.nil?
+      images = images.imagesSet
 
-      images['imagesSet']['item'].each { |image| return image['imageId'] if image['name'] == name }
+      for image in images.item do
+        return image if image.name == name
+      end
+      false
+    end
 
+    def already_registered?(name)
+      info = ami_info(name)
+      return info.imageId if info
       false
     end
 
@@ -205,47 +374,94 @@ module BoxGrinder
       guestfs.mv("/etc/fstab.new", "/etc/fstab")
     end
 
-    def wait_for_snapshot_status(status, snapshot_id)
-      snapshot = @ec2.describe_snapshots(:snapshot_id => snapshot_id)['snapshotSet']['item'].first
+    def wait_with_timeout(cycle_seconds, timeout_seconds)
+      Timeout::timeout(timeout_seconds) do
+        while not yield
+          sleep cycle_seconds
+        end
+      end
+    end
 
-      unless snapshot['status'] == status
-        sleep 2
-        wait_for_snapshot_status(status, snapshot_id)
+    def wait_for_volume_attachment(suffix)
+      wait_with_timeout(POLL_FREQ, TIMEOUT){ device_for_suffix(suffix) != nil }
+    end
+
+    def wait_for_snapshot_status(status, snapshot_id)
+      begin
+        progress = -1
+        snapshot = nil
+        wait_with_timeout(POLL_FREQ, TIMEOUT) do
+          snapshot = @ec2.describe_snapshots(:snapshot_id => snapshot_id)['snapshotSet']['item'].first
+          current_progress = snapshot.progress.to_i
+          unless progress == current_progress
+            @log.info "Progress: #{current_progress}%"
+            progress = current_progress
+          end
+          snapshot['status'] == status
+        end
+      rescue Exception
+        snapshot.ownerId='<REDACTED>' #potentially sensitive?
+        @log.debug "Polling of snapshot #{snapshot_id} for status '#{status}' failed: " <<
+        "#{PP::pp(snapshot)}" unless snapshot.nil?
+        raise
       end
     end
 
     def wait_for_volume_status(status, volume_id)
-      volume = @ec2.describe_volumes(:volume_id => volume_id)['volumeSet']['item'].first
-
-      unless volume['status'] == status
-        sleep 2
-        wait_for_volume_status(status, volume_id)
+      begin
+        volume=nil
+        wait_with_timeout(POLL_FREQ, TIMEOUT) do
+         volume = @ec2.describe_volumes(:volume_id => volume_id)['volumeSet']['item'].first
+         volume['status'] == status
+        end
+      rescue Exception
+        @log.debug "Polling of volume #{volume_id} for status '#{status}' failed: " <<
+        "#{PP::pp(volume)}" unless volume.nil?
+        raise
       end
     end
 
     def device_for_suffix(suffix)
       return "/dev/sd#{suffix}" if File.exists?("/dev/sd#{suffix}")
       return "/dev/xvd#{suffix}" if File.exists?("/dev/xvd#{suffix}")
-
-      raise "Device for suffix '#{suffix}' not found!"
+      nil
+      #raise "Device for suffix '#{suffix}' not found!"
     end
 
     def free_device_suffix
       ("f".."p").each do |suffix|
         return suffix unless File.exists?("/dev/sd#{suffix}") or File.exists?("/dev/xvd#{suffix}")
       end
-
       raise "Found too many attached devices. Cannot attach EBS volume."
     end
 
     def valid_platform?
       begin
-        return Resolv.getname("169.254.169.254").include?(".ec2.internal")
-      rescue Resolv::ResolvError
-        false
+        region = availability_zone_to_region(get_ec2_availability_zone)
+        return true if KERNELS.has_key? region
+        @log.warn "You may be using an ec2 region that BoxGrinder Build is not aware of: #{region}, BoxGrinder Build knows of: #{KERNELS.join(", ")}"
+      rescue Net::HTTPServerException => e
+        @log.warn "An error was returned when attempting to retrieve the ec2 hostname: #{e.to_s}"
+      rescue Timeout::Error => t
+        @log.warn "A timeout occurred while attempting to retrieve the ec2 hostname: #{t.to_s}"
+      end
+      false
+    end
+
+    def get_ec2_availability_zone
+      timeout(EC2_HOSTNAME_LOOKUP_TIMEOUT) do
+        req = Net::HTTP::Get.new('/latest/meta-data/placement/availability-zone/')
+        res = Net::HTTP.start('169.254.169.254', 80) {|http| http.request(req)}
+        return res.body if  Net::HTTPSuccess
+        res.error!
       end
     end
+
+    def availability_zone_to_region(availability_zone)
+      availability_zone.scan(/((\w+)-(\w+)-(\d+))/).flatten.first
+    end
+
   end
 end
 
-plugin :class => BoxGrinder::EBSPlugin, :type => :delivery, :name => :ebs, :full_name => "Elastic Block Storage"
+plugin :class => BoxGrinder::EBSPlugin, :type => :delivery, :name => :ebs, :full_name => "Elastic Block Storage"