axtro-rubber 1.0.2.8 → 1.2.0

data/lib/rubber/dns/zerigo.rb

@@ -9,6 +9,11 @@ module Rubber
       include HTTParty
       format :xml
 
+      @@zones = {}
+      def self.get_zone(domain, provider_env)
+       @@zones[domain] ||= Zone.new(provider_env.customer_id, provider_env.email, provider_env.token, domain)
+      end
+
       def initialize(customer_id, email, token, domain)
         self.class.basic_auth email, token
         self.class.base_uri "https://ns.zerigo.com/accounts/#{customer_id}"
@@ -26,31 +31,49 @@ module Rubber
         return response
       end
 
-      def hosts
-        hosts = check_status self.class.get("/zones/#{@zone['id']}/hosts.xml")
-        return hosts['hosts']
+      def create_host(opts)
+        host = opts_to_host(opts, new_host())
+        check_status self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
       end
 
-      def host(hostname)
-        hosts = check_status self.class.get("/zones/#{@zone['id']}/hosts.xml?fqdn=#{hostname}.#{@domain}")
-        return (hosts['hosts'] || []).first
-      end
+      def find_host_records(opts={})
+        result = []
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+        has_host = hn && hn != '*'
 
-      def new_host
-        check_status(self.class.get("/zones/#{@zone['id']}/hosts/new.xml"))['host']
-      end
+        url = "/zones/#{@zone['id']}/hosts.xml"
+        if has_host
+          url << "?fqdn="
+          url << "#{hn}." if hn.strip.size > 0
+          url << "#{@domain}"
+        end
+        hosts = self.class.get(url)
 
-      def create_host(host)
-        check_status self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
+        # returns 404 on not found, so don't check status
+        hosts = check_status hosts unless has_host
+
+        hosts['hosts'].each do |h|
+          keep = true
+          if ht && h['host_type'] != ht && ht != '*'
+            keep = false
+          end
+          if hd && h['data'] != hd
+            keep = false
+          end
+          result << host_to_opts(h) if keep
+        end if hosts['hosts']
+
+        return result
       end
 
-      def update_host(host)
-        host_id = host['id']
+      def update_host(host_id, opts)
+        host = opts_to_host(opts, new_host())
         check_status self.class.put("/zones/#{@zone['id']}/hosts/#{host_id}.xml", :body => {:host => host})
       end
 
-      def delete_host(hostname)
-        host_id = host(hostname)['id']
+      def delete_host(host_id)
         check_status self.class.delete("/zones/#{@zone['id']}/hosts/#{host_id}.xml")
       end
 
@@ -62,67 +85,87 @@ module Rubber
           zones = check_status self.class.get('/zones.xml')
           @zone = zones["zones"].find {|z| z["domain"] == @domain }
         end
+        if ! @zone
+          zone = new_zone()
+          zone['domain'] = @domain
+          zones = check_status self.class.post('/zones.xml', :body => {:zone => zone})
+          @zone = zones['zone']
+        end
       end
 
-      def data
+      def zone_record
         return @zone
       end
 
-      protected
+      private
 
-      def zones()
-        check_status self.class.get('/zones.xml')
+      def new_host
+        check_status(self.class.get("/zones/#{@zone['id']}/hosts/new.xml"))['host']
+      end
+
+      def new_zone
+        check_status(self.class.get("/zones/new.xml"))['zone']
+      end
+
+      def opts_to_host(opts, host={})
+        host['hostname'] = opts[:host]
+        host['host_type'] =  opts[:type]
+        host['data'] = opts[:data] if opts[:data]
+        host['ttl'] = opts[:ttl] if opts[:ttl]
+        host['priority'] = opts[:priority] if opts[:priority]
+        return host
       end
 
-      def zone(domain_name)
-        zone =  zones
-        return zone
+      def host_to_opts(host)
+        opts = {}
+        opts[:id] = host['id'] 
+        opts[:domain] = @domain
+        opts[:host] = host['hostname'] || ''
+        opts[:type] = host['host_type']
+        opts[:data] = host['data'] if host['data']
+        opts[:ttl] = host['ttl'] if host['ttl']
+        opts[:priority] = host['priority'] if host['priority']
+        return opts
       end
-      
     end
     
     class Zerigo < Base
 
       def initialize(env)
-        super(env)
-        @zerigo_env = env.dns_providers.zerigo
-        @ttl = (@zerigo_env.ttl || 300).to_i
-        @record_type = @zerigo_env.record_type || "A"
-        @zone = Zone.new(@zerigo_env.customer_id, @zerigo_env.email, @zerigo_env.token, env.domain)
+        super(env, "zerigo")
       end
 
-      def nameserver
-        "a.ns.zerigo.net"
-      end
+      def find_host_records(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = Zone.get_zone(opts[:domain], provider_env)
 
-      def host_exists?(host)
-        @zone.host(host)
+        zone.find_host_records(opts)
       end
 
-      def create_host_record(hostname, ip)
-        host = @zone.new_host()
-        host['host-type'] =  @record_type
-        host['ttl'] = @ttl
-        host['hostname'] = hostname
-        host['data'] = ip
-        @zone.create_host(host)
-      end
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        zone = Zone.get_zone(opts[:domain], provider_env)
 
-      def destroy_host_record(host)
-        @zone.delete_host(host)
+        zone.create_host(opts)
       end
 
-      def update_host_record(host, ip)
-        old = @zone.host(host)
-        old['data'] = ip
-        @zone.update_host(old)
+      def destroy_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = Zone.get_zone(opts[:domain], provider_env)
+
+        find_host_records(opts).each do |h|
+          zone.delete_host(h[:id])
+        end
       end
 
-      # update the top level domain record which has an empty hostName
-      def update_domain_record(ip)
-        old = @zone.hosts.find {|h| h['hostname'].nil? }
-        old['data'] = ip
-        @zone.update_host(old)
+      def update_host_record(old_opts={}, new_opts={})
+        old_opts = setup_opts(old_opts, [:host, :domain])
+        new_opts = setup_opts(new_opts.merge(:no_defaults =>true), [])
+        zone = Zone.get_zone(old_opts[:domain], provider_env)
+
+        find_host_records(old_opts).each do |h|
+          zone.update_host(h[:id], h.merge(new_opts))
+        end
       end
 
     end

data/lib/rubber/environment.rb

@@ -32,6 +32,8 @@ module Rubber
         roles_dir = File.join(@config_root, "role")
         roles = Dir.entries(roles_dir)
         roles.delete_if {|d| d =~ /(^\..*)/}
+        roles += @items['roles'].keys
+        return roles.compact.uniq
       end
 
       def current_host
@@ -41,7 +43,7 @@ module Rubber
       def current_full_host
         Socket::gethostname
       end
-
+      
       def bind(roles = nil, host = nil)
         BoundEnv.new(@items, roles, host)
       end
@@ -77,6 +79,10 @@ module Rubber
           replace(receiver)
         end
 
+        def rubber_instances
+          @rubber_instances ||= Rubber::Configuration::rubber_instances
+        end
+
         def [](name)
           value = super(name)
           value = global[name] if global && !value
@@ -122,14 +128,16 @@ module Rubber
       class BoundEnv < HashValueProxy
         attr_reader :roles
         attr_reader :host
-        attr_reader :full_host
 
         def initialize(global, roles, host)
           @roles = roles
           @host = host
           bound_global = bind_config(global)
           super(nil, bound_global)
-          @full_host = "#{host}.#{domain}" rescue nil
+        end
+
+        def full_host
+          @full_host ||= "#{host}.#{domain}" rescue nil
         end
 
         # Forces role/host overrides into config

data/lib/rubber/instance.rb

@@ -81,6 +81,8 @@ module Rubber
       attr_accessor :external_host, :external_ip
       attr_accessor :internal_host, :internal_ip
       attr_accessor :static_ip, :volumes, :partitions
+      attr_accessor :spot_instance_request_id
+      attr_accessor :platform
 
       def initialize(name, domain, roles, instance_id, security_group_list=[])
         @name = name
@@ -97,6 +99,15 @@ module Rubber
       def role_names()
         roles.collect {|r| r.name}
       end
+
+      def platform
+        # Deal with old instance configurations that don't have a platform value persisted.
+        @platform || 'linux'
+      end
+
+      def windows?
+        platform == 'windows'
+      end
     end
 
     # The configuration for a single role contained in the list

data/lib/rubber/recipes/rubber/instances.rb

@@ -5,7 +5,13 @@ namespace :rubber do
   DESC
   required_task :create do
     instance_alias = get_env('ALIAS', "Instance alias (e.g. web01)", true)
-    r = get_env('ROLES', "Instance roles (e.g. web,app,db:primary=true)", true)
+
+    env = rubber_cfg.environment.bind(nil, instance_alias)
+    default_roles = env.instance_roles
+    r = get_env("ROLES", "Instance roles (e.g. web,app,db:primary=true)", true, default_roles)
+
+    create_spot_instance = ENV.delete("SPOT_INSTANCE") || env.cloud_providers[env.cloud_provider].spot_instance
+
     if r == '*'
       instance_roles = rubber_cfg.environment.known_roles
       instance_roles = instance_roles.collect {|role| role == "db" ? "db:primary=true" : role }
@@ -29,7 +35,7 @@ namespace :rubber do
     # Add in roles that the given set of roles depends on
     ir = Rubber::Configuration::RoleItem.expand_role_dependencies(ir, get_role_dependencies)
 
-    create_instance(instance_alias, ir)
+    create_instance(instance_alias, ir, create_spot_instance)
   end
 
   desc <<-DESC
@@ -83,6 +89,10 @@ namespace :rubber do
 
     instance.roles = (instance.roles + ir).uniq
     rubber_instances.save()
+    logger.info "Roles for #{instance_alias} are now:"
+    logger.info instance.role_names.sort.join("\n")
+    logger.info ''
+    logger.info "Run 'cap rubber:bootstrap' if done adding roles"
   end
 
   desc <<-DESC
@@ -105,6 +115,8 @@ namespace :rubber do
 
     instance.roles = (instance.roles - ir).uniq
     rubber_instances.save()
+    logger.info "Roles for #{instance_alias} are now:"
+    logger.info instance.role_names.sort.join("\n")
   end
 
   desc <<-DESC
@@ -144,7 +156,7 @@ namespace :rubber do
 
   # Creates a new ec2 instance with the given alias and roles
   # Configures aliases (/etc/hosts) on local and remote machines
-  def create_instance(instance_alias, instance_roles)
+  def create_instance(instance_alias, instance_roles, create_spot_instance=false)
     fatal "Instance already exists: #{instance_alias}" if rubber_instances[instance_alias]
 
     role_names = instance_roles.collect{|x| x.name}
@@ -157,12 +169,45 @@ namespace :rubber do
     ami = env.cloud_providers[env.cloud_provider].image_id
     ami_type = env.cloud_providers[env.cloud_provider].image_type
     availability_zone = env.availability_zone
-    logger.info "Creating instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
-    instance_id = cloud.create_instance(ami, ami_type, security_groups, availability_zone)
+
+    if create_spot_instance
+      spot_price = env.cloud_providers[env.cloud_provider].spot_price.to_s
+
+      logger.info "Creating spot instance request for instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
+      request_id = cloud.create_spot_instance_request(spot_price, ami, ami_type, security_groups, availability_zone)
+
+      print "Waiting for spot instance request to be fulfilled"
+      max_wait_time = env.cloud_providers[env.cloud_provider].spot_instance_request_timeout || (1.0 / 0) # Use the specified timeout value or default to infinite.
+      instance_id = nil
+      while instance_id.nil? do
+        print "."
+        sleep 2
+        max_wait_time -= 2
+
+        request = cloud.describe_spot_instance_requests(request_id).first
+        instance_id = request[:instance_id]
+
+        if max_wait_time < 0 && instance_id.nil?
+          cloud.destroy_spot_instance_request(request[:id])
+
+          print "\n"
+          print "Failed to fulfill spot instance in the time specified. Falling back to on-demand instance creation."
+          break
+        end
+      end
+
+      print "\n"
+    end
+
+    if !create_spot_instance || (create_spot_instance && max_wait_time < 0)
+      logger.info "Creating instance #{ami}/#{ami_type}/#{security_groups.join(',') rescue 'Default'}/#{availability_zone || 'Default'}"
+      instance_id = cloud.create_instance(ami, ami_type, security_groups, availability_zone)
+    end
 
     logger.info "Instance #{instance_id} created"
 
     instance_item = Rubber::Configuration::InstanceItem.new(instance_alias, env.domain, instance_roles, instance_id, security_groups)
+    instance_item.spot_instance_request_id = request_id if create_spot_instance
     rubber_instances.add(instance_item)
     rubber_instances.save()
 
@@ -180,6 +225,7 @@ namespace :rubber do
         instance_item.external_ip = instance[:external_ip]
         instance_item.internal_host = instance[:internal_host]
         instance_item.zone = instance[:zone]
+        instance_item.platform = instance[:platform]
         rubber_instances.save()
 
         # setup amazon elastic ips if configured to do so
@@ -196,7 +242,14 @@ namespace :rubber do
         # so that we can update all aliases
 
         task :_get_ip, :hosts => instance_item.external_ip do
-          instance_item.internal_ip = capture(print_ip_command).strip
+          # There's no good way to get the internal IP for a Windows host, so just set it to the external
+          # and let the router handle mapping to the internal network.
+          if instance_item.windows?
+            instance_item.internal_ip = instance_item.external_ip
+          else
+            instance_item.internal_ip = capture(print_ip_command).strip
+          end
+
           rubber_instances.save()
         end
 

data/lib/rubber/recipes/rubber/security_groups.rb

@@ -36,7 +36,7 @@ namespace :rubber do
       security_groups << host
       security_groups += roles
     end
-    security_groups = security_groups.uniq.compact
+    security_groups = security_groups.uniq.compact.reject {|x| x.empty? }
     security_groups = security_groups.collect {|x| isolate_group_name(x) } if env.isolate_security_groups
     return security_groups
   end

data/lib/rubber/recipes/rubber/setup.rb

@@ -1,5 +1,8 @@
 namespace :rubber do
 
+  # Disable connecting to any Windows instance.
+  set :default_run_options, :except => { :platform => 'windows' }
+
   desc <<-DESC
     Bootstraps instances by setting timezone, installing packages and gems
   DESC
@@ -61,6 +64,83 @@ namespace :rubber do
     end
   end
 
+  desc <<-DESC
+    Sets up the additional dns records supplied in the dns_records config in rubber.yml
+  DESC
+  required_task :setup_dns_records do
+    records = rubber_env.dns_records
+    if records && rubber_env.dns_provider
+      provider = Rubber::Dns::get_provider(rubber_env.dns_provider, rubber_env)
+
+      # collect the round robin records (those with the same host/domain/type)
+      rr_records = []
+      records.each_with_index do |record, i|
+        m = records.find_all {|r| record['host'] == r['host'] && record['domain'] == r['domain'] && record['type'] == r['type']}
+        m = m.sort {|a,b| a.object_id <=> b.object_id}
+        rr_records << m if m.size > 1 && ! rr_records.include?(m)
+      end
+
+      # simple records are those that aren't round robin ones
+      simple_records = records - rr_records.flatten
+      
+      # for each simple record, create or update as necessary
+      simple_records.each do |record|
+        matching = provider.find_host_records(:host => record['host'], :domain =>record['domain'], :type => record['type'])
+        if matching.size > 1
+          msg =  "Multiple records in dns provider, but not in rubber.yml\n"
+          msg << "Round robin records need to be in both, or neither.\n"
+          msg << "Please fix manually:\n"
+          msg << matching.pretty_inspect
+          fatal(msg)
+        end
+
+        record = provider.setup_opts(record)
+        if matching.size == 1
+          match = matching.first
+          if  provider.host_records_equal?(record, match)
+            logger.info "Simple dns record already up to date: #{record[:host]}.#{record[:domain]}:#{record[:type]} => #{record[:data]}"
+          else
+            logger.info "Updating simple dns record: #{record[:host]}.#{record[:domain]}:#{record[:type]} => #{record[:data]}"
+            provider.update_host_record(match, record)
+          end
+        else
+          logger.info "Creating simple dns record: #{record[:host]}.#{record[:domain]}:#{record[:type]} => #{record[:data]}"
+          provider.create_host_record(record)
+        end
+      end
+
+      # group round robin records
+      rr_records.each do |rr_group|
+        host = rr_group.first['host']
+        domain = rr_group.first['domain']
+        type = rr_group.first['type']
+        matching = provider.find_host_records(:host => host, :domain => domain, :type => type)
+
+        # remove from consideration the local records that are the same as remote ones
+        matching.clone.each do |r|
+          rr_group.delete_if {|rg| provider.host_records_equal?(r, rg) }
+          matching.delete_if {|rg| provider.host_records_equal?(r, rg) }
+        end
+        if rr_group.size == 0 && matching.size == 0
+          logger.info "Round robin dns records already up to date: #{host}.#{domain}:#{type}"
+        end
+
+        # create the local records that don't exist remotely
+        rr_group.each do |r|
+          r = provider.setup_opts(r)
+          logger.info "Creating round robin dns record: #{r[:host]}.#{r[:domain]}:#{r[:type]} => #{r[:data]}"
+          provider.create_host_record(r)
+        end
+        
+        # remove the remote records that don't exist locally
+        matching.each do |r|
+          logger.info "Removing round robin dns record: #{r[:host]}.#{r[:domain]}:#{r[:type]} => #{r[:data]}"
+          provider.destroy_host_record(r)
+        end
+      end
+    end
+  end
+
   desc <<-DESC
     Sets up aliases for instance hostnames based on contents of instance.yml.
     Generates /etc/hosts for remote machines and sets hostname on remote instances
@@ -144,11 +224,33 @@ namespace :rubber do
   desc <<-DESC
     Install ruby gems defined in the rails environment.rb
   DESC
-  after "deploy:symlink", "rubber:install_rails_gems" if Rubber::Util.is_rails?
+  after "rubber:config", "rubber:install_rails_gems" if Rubber::Util.is_rails?
   task :install_rails_gems do
     sudo "sh -c 'cd #{current_path} && RAILS_ENV=#{RUBBER_ENV} rake gems:install'"
   end
 
+  desc <<-DESC
+    Convenience task for installing your defined set of ruby gems locally.
+  DESC
+  required_task :install_local_gems do
+    fatal("install_local_gems can only be run in development") if RUBBER_ENV != 'development'
+    env = rubber_cfg.environment.bind(rubber_cfg.environment.known_roles)
+    gems = env['gems']
+    expanded_gem_list = []
+    gems.each do |gem_spec|
+      if gem_spec.is_a?(Array)
+        expanded_gem_list << "#{gem_spec[0]}:#{gem_spec[1]}"
+      else
+        expanded_gem_list << gem_spec
+      end
+    end
+    expanded_gem_list = expanded_gem_list.join(' ')
+
+    logger.info "Installing gems:#{expanded_gem_list}"
+    open("/tmp/gem_helper", "w") {|f| f.write(gem_helper_script)}
+    system "sh /tmp/gem_helper install #{expanded_gem_list}"
+  end
+
   desc <<-DESC
     Setup ruby gems sources. Set 'gemsources' in rubber.yml to \
     be an array of URI strings.
@@ -280,11 +382,61 @@ namespace :rubber do
     end
   end
 
+  # Rubygems always installs even if the gem is already installed
+  # When providing versions, rubygems fails unless versions are provided for all gems
+  # This helper script works around these issues by installing gems only if they
+  # aren't already installed, and separates versioned/unversioned into two separate
+  # calls to rubygems
+  #
+  set :gem_helper_script, <<-'ENDSCRIPT'
+    ruby - $@ <<-'EOF'
+
+    gem_cmd = ARGV[0]
+    gems = ARGV[1..-1]
+    cmd = "gem #{gem_cmd} --no-rdoc --no-ri"
+
+    to_install = {}
+    to_install_ver = {}
+    # gem list passed in, possibly with versions, as "gem1 gem2:1.2 gem3"
+    gems.each do |gem_spec|
+      parts = gem_spec.split(':')
+      if parts[1]
+        to_install_ver[parts[0]] = parts[1]
+      else
+        to_install[parts[0]] = true
+      end
+    end
+
+    installed = {}
+    `gem list --local`.each do |line|
+        parts = line.scan(/(.*) \((.*)\)/).first
+        next unless parts && parts.size == 2
+        installed[parts[0]] = parts[1].split(",")
+    end
+
+    to_install.delete_if {|g, v| installed.has_key?(g) } if gem_cmd == 'install'
+    to_install_ver.delete_if {|g, v| installed.has_key?(g) && installed[g].include?(v) }
+
+    # rubygems can only do asingle versioned gem at a time so we need
+    # to do the two groups separately
+    # install versioned ones first so unversioned don't pull in a newer version
+    to_install_ver.each do |g, v|
+      system "#{cmd} #{g} -v #{v}"
+      fail "Unable to install versioned gem #{g}:#{v}" if $?.exitstatus > 0
+    end
+    if to_install.size > 0
+      gem_list = to_install.keys.join(' ')
+      system "#{cmd} #{gem_list}"
+      fail "Unable to install gems" if $?.exitstatus > 0
+    end
+
+    'EOF'
+  ENDSCRIPT
+
   # Helper for installing gems,allows one to respond to prompts
   def gem_helper(update=false)
     cmd = update ? "update" : "install"
 
-
     opts = get_host_options('gems') do |gem_list|
       expanded_gem_list = []
       gem_list.each do |gem_spec|
@@ -298,56 +450,7 @@ namespace :rubber do
     end
     
     if opts.size > 0
-      # Rubygems always installs even if the gem is already installed
-      # When providing versions, rubygems fails unless versions are provided for all gems
-      # This helper script works around these issues by installing gems only if they
-      # aren't already installed, and separates versioned/unversioned into two separate
-      # calls to rubygems
-      script = prepare_script 'gem_helper', <<-'ENDSCRIPT'
-        ruby - $@ <<-'EOF'
-
-        gem_cmd = ARGV[0]
-        gems = ARGV[1..-1]
-        cmd = "gem #{gem_cmd} --no-rdoc --no-ri"
-
-        to_install = {}
-        to_install_ver = {}
-        # gem list passed in, possibly with versions, as "gem1 gem2:1.2 gem3"
-        gems.each do |gem_spec|
-          parts = gem_spec.split(':')
-          if parts[1]
-            to_install_ver[parts[0]] = parts[1]
-          else
-            to_install[parts[0]] = true
-          end
-        end
-
-        installed = {}
-        `gem list --local`.each do |line|
-            parts = line.scan(/(.*) \((.*)\)/).first
-            next unless parts && parts.size == 2
-            installed[parts[0]] = parts[1].split(",")
-        end
-
-        to_install.delete_if {|g, v| installed.has_key?(g) } if gem_cmd == 'install'
-        to_install_ver.delete_if {|g, v| installed.has_key?(g) && installed[g].include?(v) } 
-
-        # rubygems can only do asingle versioned gem at a time so we need
-        # to do the two groups separately
-        # install versioned ones first so unversioned don't pull in a newer version
-        to_install_ver.each do |g, v|
-          system "#{cmd} #{g} -v #{v}"
-          fail "Unable to install versioned gem #{g}:#{v}" if $?.exitstatus > 0
-        end
-        if to_install.size > 0
-          gem_list = to_install.keys.join(' ')
-          system "#{cmd} #{gem_list}"
-          fail "Unable to install gems" if $?.exitstatus > 0
-        end
-
-        'EOF'
-      ENDSCRIPT
-
+      script = prepare_script('gem_helper', gem_helper_script)
       sudo "sh #{script} #{cmd} $CAPISTRANO:VAR$", opts do |ch, str, data|
         handle_gem_prompt(ch, data, str)
       end

data/lib/rubber/recipes/rubber/spot_requests.rb

@@ -0,0 +1,23 @@
+namespace :rubber do
+
+  desc "Describes all your spot instance requests"
+  required_task :describe_spot_instance_requests do
+    requests = cloud.describe_spot_instance_requests()
+    requests.each do |request|
+      logger.info "======================"
+      logger.info "ID: #{request[:id]}"
+      logger.info "Created at: #{request[:created_at]}"
+      logger.info "Max. price: $#{request[:spot_price]}"
+      logger.info "State: #{request[:state]}"
+      logger.info "Instance type: #{request[:type]}"
+      logger.info "AMI: #{request[:image_id]}"
+    end
+  end
+
+  desc "Cancel the spot instances request for the given id"
+  required_task :cancel_spot_instances_request do
+    request_id = get_env('SPOT_INSTANCE_REQUEST_ID', 'The id of the spot instances request to cancel', true)
+    cloud.destroy_spot_instance_request(request_id)
+  end
+
+end