rubber 1.15.0 → 2.0.0.pre1

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  # - rbx-19mode
+# script: bundle exec rspec spec

data/CHANGELOG

@@ -1,4 +1,72 @@
+2.0.0.pre1 (02/03/2012)
+----------
+
+New Features:
+============
+
+Refactored cloud layer to use fog, implement rubber use of aws/s3 with fog
+Abstract out s3 to go through rubber cloud layer (fog)
+Allow simpledb, s3 or alternate file for instance storage, with backups to same
+Added Graylog recipe
+Added Elasticsearch recipe
+Added Unicorn recipe [Thanks Alex Kremer]
+Added Graphite recipe
+Added Collectd recipe
+Added Graylog to complete_passenger template
+Make collectd/graphite default instead of munin
+Use resque-pool to manage resque workers
+Option to reboot if neccessary after package update
+Added a rubber binary and used it for running everything (cron, etc, removed dependency on rake)
+
+Improvements:
+============
+
+Start using upstart for all daemons (complete_passenger_postgresql, resque, graylog) 
+Better discovery of roles, default staging instance to these roles
+Replace global RUBBER_* vars in ruby with Rubber.*
+Bump image to latest 10.04
+check harder when determining project roles <7570d47> [Matt Conway]
+Cleanup crosscutting templates (monit, munin, collectd) to be self contained
+Remove hard dependency on nettica and lazy load it
+Upgraded config for PostgreSQL 9.1. [Thanks Kevin Menard]
+Upgraded to redis 2.4. [Thanks Kevin Menard]
+Bump rvm/ruby/rake/rubygems versions
+Bump passenger version
+Asset pipeline support for rails 3.1, cleanup some rails detection issues
+Extract fog dns from zerigo to allow other providers
+Respawn cap/rake with bundler if needed
+Proxy services on their own tools subhost to avoid issues with rewriting paths in CSS and JS [Thanks Kevin Menard]
+Automate web tools proxy mappings for IP aliases in /etc/host, dns, and web_tools index and vhosts files
+Added a rails template for creating a rails app to test rubber
+Include instance_type in rubber:describe
+Replaced zerigo_dns gem usage with fog [Thanks Kevin Menard]
+
+
+Bug Fixes:
+==========
+
+fix mongo monit to remove pidfile or mongo won't start
+fix mongo bootstrap
+make start/stop consistent, only restart when bootstrap necessary
+fix redis bootstrap
+fix resque_web bootstrap
+update redis to use upstart, thereby removing hackish dual install
+fix rvm installer url
+add back in base postgresql role
+fix db backup host
+validate config set, create image bucket on bundle
+made setup_remote_aliases update /etc/hosts for each host directly, preserve ordering to be consistent with setup_local_aliases
+Fix volume mounting [Thanks Alex Kremer]
+We shouldn't have a dependency on plpythonu. [Thanks Kevin Menard]
+Fixes to nginx/passenger [Thanks Ajay Kumar G]
+make sure open4 gets bundled
+fix create_staging for pre-existing instance
+Ensure Zerigo makes calls using XML in 3.1 [Thanks Alex Kremer]
+Fix suggestion in rubber.yml on how to list availability zones. [Thanks Maxim Chernyak aka hakunin]
+Locked the default version of Ruby down to a particular patch release so by default an entire cluster will use the same ruby [Thanks Kevin Menard]
+
 1.15.0 (09/13/2011)
+-----
 
 New Features:
 ============
@@ -32,7 +100,6 @@ Fixed compatibility issues with the Psych parser used in Ruby 1.9.2 (thanks Kevi
 Fixed timing issue with multiple resque workers starting (thanks Matt Conway)
 Fixed an issue with hostnames that happen to be monit commands (thanks Michael Glass)
 
-
 1.14.1 (06/02/2011)
 -----
 

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rubber.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,89 @@
+gemfile = File.expand_path(File.join(__FILE__, '..', 'Gemfile'))
+if File.exist?(gemfile) && ENV['BUNDLE_GEMFILE'].nil?
+  puts "Respawning with 'bundle exec rake'"
+  exec("bundle", "exec", "rake", *ARGV)
+end
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/testtask'
+
+task :my_release => ['changelog', 'release'] do
+end
+
+task :changelog do
+
+  helper = Bundler::GemHelper.new(Dir.pwd)
+  version = "v#{helper.gemspec.version}"
+
+  changelog_file = 'CHANGELOG'
+  entries = ""
+
+  # Get a list of current tags
+  tags = `git tag -l`.split
+  tags = tags.sort_by {|t| t[1..-1].split(".").collect {|s| s.to_i } }
+  newest_tag = tags[-1]
+
+  if version == newest_tag
+    puts "You need to update version, same as most recent tag: #{version}"
+    exit
+  end
+
+  # If we already have a changelog, make the last tag be the
+  # last one in the changelog, and the next one be the one
+  # following that in the tag list
+  newest_changelog_version = nil
+  if File.exist?(changelog_file)
+    entries = File.read(changelog_file)
+    head = entries.split.first
+    if head =~ /\d\.\d\.\d/
+      newest_changelog_version = "v#{head}"
+
+      if version == newest_changelog_version
+        puts "You need to update version, same as most recent changelog: #{version}"
+        exit
+      end
+
+    end
+  end
+
+  # Generate changelog from repo
+  log=`git log --pretty='format:%s <%h> [%cn]' #{newest_tag}..HEAD`
+
+  # Strip out maintenance entries
+  log = log.lines.to_a.delete_if do |l|
+     l =~ /^Regenerated? gemspec/ ||
+         l =~ /^version bump/i ||
+         l =~ /^Updated changelog/ ||
+         l =~ /^Merged? branch/
+  end
+
+  # Write out changelog file
+  File.open(changelog_file, 'w') do |out|
+    out.puts version.gsub(/^v/, '')
+    out.puts "-----"
+    out.puts "\n"
+    out.puts log
+    out.puts "\n"
+    out.puts entries
+  end
+
+  # Commit and push
+  unless ENV['NO_PUSH']
+    sh "git ci -m'Updated changelog' #{changelog_file}"
+    sh "git push"
+  end
+end
+
+desc 'Test the rubber plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Default: run unit tests.'
+task :default => :test

data/bin/rubber

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+env = ENV['RUBBER_ENV'] ||= 'development'
+root = File.expand_path(ENV['RUBBER_ROOT'] || '.')
+
+# Only load gemfile if there and contains rubber in order
+# to allow vulcanize to work in bootstrap case
+gemfile = ENV['BUNDLE_GEMFILE'] || "#{root}/Gemfile"
+if File.exists?(gemfile) && File.read(gemfile).lines.grep(/^[^#]*gem.*["']rubber["']/).size > 0
+  require "bundler"
+  Bundler.setup(:default, env.to_sym)
+end
+
+require 'rubber'
+Rubber::initialize(root, env)
+
+require 'rubber/cli'
+Rubber::CLI.run

data/lib/rubber.rb

@@ -2,8 +2,6 @@ $:.unshift(File.dirname(__FILE__))
 
 module Rubber
 
-  @@version  = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp
-
   def self.initialize(project_root, project_env)
     return if defined?(RUBBER_ROOT) && defined?(RUBBER_ENV)
 
@@ -17,7 +15,7 @@ module Rubber
       # We actually do NOT want the entire rails environment because it
       # complicates bootstrap (i.e. can't run config to create db because full
       # rails env needs db to exist as some plugin accesses model or something)
-      rails_boot_file = File.join(RUBBER_ROOT, 'config', 'boot.rb')
+      rails_boot_file = File.join(Rubber.root, 'config', 'boot.rb')
       require(rails_boot_file) if File.exists? rails_boot_file
     end
 
@@ -44,7 +42,7 @@ module Rubber
   end
 
   def self.version
-    @@version
+    Rubber::VERSION
   end
 
   def self.logger
@@ -58,9 +56,17 @@ module Rubber
   def self.instances
     Rubber::Configuration.rubber_instances
   end
+  
+  def self.cloud(capistrano = nil)
+    # sharing a Net::HTTP instance across threads doesn't work, so
+    # create a new instance per thread
+    Rubber::ThreadSafeProxy.new { Rubber::Cloud::get_provider(self.config.cloud_provider || "aws", self.config, capistrano) }
+  end
+  
 end
 
 
+require 'rubber/version'
 require 'rubber/thread_safe_proxy'
 require 'rubber/configuration'
 require 'rubber/environment'
@@ -70,8 +76,8 @@ require 'rubber/util'
 require 'rubber/cloud'
 require 'rubber/dns'
 
-if Rubber::Util::is_rails3?
+if defined?(Rails::Railtie)
   module Rubber
     require 'rubber/railtie'
   end
-end
+end

data/lib/rubber/cli.rb

@@ -0,0 +1,30 @@
+require "clamp"
+
+# require all the rubber commands
+files = Dir[File.expand_path(File.join(File.dirname(__FILE__), 'commands/*.rb'))]
+files.each do |f|
+  require f
+end
+
+module Rubber
+
+  class CLI < Clamp::Command
+    
+    # setup clamp subcommands for each rubber command
+    command_classes = []
+    Rubber::Commands.constants.each do |c|
+      clazz = Rubber::Commands.const_get(c)
+      if clazz.class == Class && clazz.ancestors.include?(Clamp::Command) &&
+         clazz.respond_to?(:subcommand_name) && clazz.respond_to?(:subcommand_description)
+        subcommand clazz.subcommand_name, clazz.subcommand_description, clazz
+      end
+    end
+    
+    option ["-v", "--version"], :flag, "print version" do
+      puts Rubber.version
+      exit 0
+    end
+    
+  end
+  
+end

data/lib/rubber/cloud.rb

@@ -6,7 +6,8 @@ module Rubber
     def self.get_provider(provider, env, capistrano)
       require "rubber/cloud/#{provider}"
       clazz = Rubber::Cloud.const_get(provider.capitalize)
-      return clazz.new(env, capistrano)
+      provider_env = env.cloud_providers[provider]
+      return clazz.new(provider_env, capistrano)
     end
 
   end

data/lib/rubber/cloud/aws.rb

@@ -1,236 +1,48 @@
-require 'rubygems'
-require 'AWS'
-require 'aws/s3'
+require 'rubber/cloud/fog'
+require 'rubber/cloud/aws_table_store'
 
 module Rubber
   module Cloud
-
-    class Aws < Base
-
+  
+    class Aws < Fog
+      
       def initialize(env, capistrano)
+        
+        credentials = {
+            :aws_access_key_id => env.access_key,
+            :aws_secret_access_key => env.secret_access_key
+        }
+        
+        @table_store = ::Fog::AWS::SimpleDB.new(credentials)
+        
+        credentials[:region] = env.region
+        @elb = ::Fog::AWS::ELB.new(credentials)
+        
+        credentials[:provider] = 'AWS'
+        env['credentials'] = credentials
         super(env, capistrano)
-        @aws_env = env.cloud_providers.aws
-        @ec2 = AWS::EC2::Base.new(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key, :server => @aws_env.server_endpoint)
-        @ec2elb = AWS::ELB::Base.new(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key, :server => @aws_env.server_endpoint)
-        AWS::S3::Base.establish_connection!(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key, :server => @aws_env.server_endpoint)
-      end
-
-      def create_instance(ami, ami_type, security_groups, availability_zone)
-        response = @ec2.run_instances(:image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone)
-        instance_id = response.instancesSet.item[0].instanceId
-        return instance_id
-      end
-
-      def create_spot_instance_request(spot_price, ami, ami_type, security_groups, availability_zone)
-        response = @ec2.request_spot_instances(:spot_price => spot_price, :image_id => ami, :key_name => @aws_env.key_name, :instance_type => ami_type, :security_group => security_groups, :availability_zone => availability_zone)
-        request_id = response.spotInstanceRequestSet.item[0].spotInstanceRequestId
-        return request_id
-      end
-
-      def describe_instances(instance_id=nil)
-        instances = []
-        opts = {}
-        opts[:instance_id] = instance_id if instance_id
-
-        response = @ec2.describe_instances(opts)
-        response.reservationSet.item.each do |ritem|
-          ritem.instancesSet.item.each do |item|
-            instance = {}
-            instance[:id] = item.instanceId
-            instance[:external_host] = item.dnsName
-            instance[:external_ip] = item.ipAddress
-            instance[:internal_host] = item.privateDnsName
-            instance[:internal_ip] = item.privateIpAddress
-            instance[:state] = item.instanceState.name
-            instance[:zone] = item.placement.availabilityZone
-            instance[:platform] = item.platform || 'linux'
-            instance[:root_device_type] = item.rootDeviceType
-            instances << instance
-          end
-        end if response.reservationSet
-
-        return instances
-      end
-
-      def destroy_instance(instance_id)
-        response = @ec2.terminate_instances(:instance_id => instance_id)
-      end
-
-      def reboot_instance(instance_id)
-        response = @ec2.reboot_instances(:instance_id => instance_id)
       end
-
-      def stop_instance(instance_id)
-        # Don't force the stop process. I.e., allow the instance to flush its file system operations.
-        response = @ec2.stop_instances(:instance_id => instance_id, :force => false)
-      end
-
-      def start_instance(instance_id)
-        response = @ec2.start_instances(:instance_id => instance_id)
-      end
-
-      def describe_availability_zones
-        zones = []
-        response = @ec2.describe_availability_zones()
-        response.availabilityZoneInfo.item.each do |item|
-          zone = {}
-          zone[:name] = item.zoneName
-          zone[:state] =item.zoneState
-          zones << zone
-        end if response.availabilityZoneInfo
-        return zones
-      end
-
-      def create_security_group(group_name, group_description)
-        @ec2.create_security_group(:group_name => group_name, :group_description => group_description)
-      end
-
-      def describe_security_groups(group_name=nil)
-        groups = []
-
-        opts = {}
-        opts[:group_name] = group_name if group_name
-        response = @ec2.describe_security_groups(opts)
-
-        response.securityGroupInfo.item.each do |item|
-          group = {}
-          group[:name] = item.groupName
-          group[:description] = item.groupDescription
-
-          item.ipPermissions.item.each do |ip_item|
-            group[:permissions] ||= []
-            rule = {}
-
-            rule[:protocol] = ip_item.ipProtocol
-            rule[:from_port] = ip_item.fromPort
-            rule[:to_port] = ip_item.toPort
-
-            ip_item.groups.item.each do |rule_group|
-              rule[:source_groups] ||= []
-              source_group = {}
-              source_group[:account] = rule_group.userId
-              source_group[:name] = rule_group.groupName
-              rule[:source_groups] << source_group
-            end if ip_item.groups
-
-            ip_item.ipRanges.item.each do |ip_range|
-              rule[:source_ips] ||= []
-              rule[:source_ips] << ip_range.cidrIp
-            end if ip_item.ipRanges
-
-            group[:permissions] << rule
-          end if item.ipPermissions
-
-          groups << group
-          
-        end if response.securityGroupInfo
-
-        return groups
-      end
-
-      def add_security_group_rule(group_name, protocol, from_port, to_port, source)
-        opts = {:group_name => group_name}
-        if source.instance_of? Hash
-          opts = opts.merge(:source_security_group_name => source[:name], :source_security_group_owner_id => source[:account])
-        else
-          opts = opts.merge(:ip_protocol => protocol, :from_port => from_port, :to_port => to_port, :cidr_ip => source)
-        end
-        @ec2.authorize_security_group_ingress(opts)
-      end
-
-      def remove_security_group_rule(group_name, protocol, from_port, to_port, source)
-        opts = {:group_name => group_name}
-        if source.instance_of? Hash
-          opts = opts.merge(:source_security_group_name => source[:name], :source_security_group_owner_id => source[:account])
-        else
-          opts = opts.merge(:ip_protocol => protocol, :from_port => from_port, :to_port => to_port, :cidr_ip => source)
-        end
-        @ec2.revoke_security_group_ingress(opts)
+      
+      def table_store(table_key)
+        return Rubber::Cloud::AwsTableStore.new(@table_store, table_key)  
       end
-
-      def destroy_security_group(group_name)
-        @ec2.delete_security_group(:group_name => group_name)
-      end
-
-      def create_static_ip
-        response = @ec2.allocate_address()
-        return response.publicIp
-      end
-
-      def attach_static_ip(ip, instance_id)
-        response = @ec2.associate_address(:instance_id => instance_id, :public_ip => ip)
-        return response.return == "true"
-      end
-
-      def detach_static_ip(ip)
-        response = @ec2.disassociate_address(:public_ip => ip)
-        return response.return == "true"
-      end
-
-      def describe_static_ips(ip=nil)
-        ips = []
-        opts = {}
-        opts[:public_ip] = ip if ip
-        response = @ec2.describe_addresses(opts)
-        response.addressesSet.item.each do |item|
-          ip = {}
-          ip[:instance_id] = item.instanceId
-          ip[:ip] = item.publicIp
-          ips << ip
-        end if response.addressesSet
-        return ips
-      end
-
-      def destroy_static_ip(ip)
-        response = @ec2.release_address(:public_ip => ip)
-        return response.return == "true"
-      end
-
-      def create_volume(size, zone)
-        response = @ec2.create_volume(:size => size.to_s, :availability_zone => zone)
-        return response.volumeId
-      end
-
-      def attach_volume(volume_id, instance_id, device)
-        response = @ec2.attach_volume(:volume_id => volume_id, :instance_id => instance_id, :device => device)
-        return response.status
-      end
-
-      def detach_volume(volume_id)
-        @ec2.detach_volume(:volume_id => volume_id, :force => 'true')
-      end
-
-      def describe_volumes(volume_id=nil)
-        volumes = []
-        opts = {}
-        opts[:volume_id] = volume_id if volume_id
-        response = @ec2.describe_volumes(opts)
-        response.volumeSet.item.each do |item|
-          volume = {}
-          volume[:id] = item.volumeId
-          volume[:status] = item.status
-          if item.attachmentSet
-            attach = item.attachmentSet.item[0]
-            volume[:attachment_instance_id] = attach.instanceId
-            volume[:attachment_status] = attach.status
-          end
-          volumes << volume
-        end if response.volumeSet
-        return volumes
-      end
-
-      def destroy_volume(volume_id)
-        @ec2.delete_volume(:volume_id => volume_id)
-      end
-
+      
       def create_image(image_name)
-        ec2_key = @aws_env.key_file
-        ec2_pk = @aws_env.pk_file
-        ec2_cert = @aws_env.cert_file
+        ec2_key = env.key_file
+        ec2_pk = env.pk_file
+        ec2_cert = env.cert_file
         ec2_key_dest = "/mnt/#{File.basename(ec2_key)}"
         ec2_pk_dest = "/mnt/#{File.basename(ec2_pk)}"
         ec2_cert_dest = "/mnt/#{File.basename(ec2_cert)}"
 
+        # validate all needed config set
+        ["key_file", "pk_file", "cert_file", "account", "secret_access_key", "image_bucket"].each do |k|
+          raise "Set #{k} in rubber.yml" unless "#{env[k]}".strip.size > 0
+        end
+        raise "create_image can only be called from a capistrano scope" unless capistrano
+        
+        storage(env.image_bucket).ensure_bucket
+        
         capistrano.put(File.read(ec2_key), ec2_key_dest)
         capistrano.put(File.read(ec2_pk), ec2_pk_dest)
         capistrano.put(File.read(ec2_cert), ec2_cert_dest)
@@ -242,7 +54,7 @@ module Rubber
           rvm use system
           export RUBYLIB=/usr/lib/site_ruby/
           unset RUBYOPT
-          nohup ec2-bundle-vol --batch -d /mnt -k #{ec2_pk_dest} -c #{ec2_cert_dest} -u #{@aws_env.account} -p #{image_name} -r #{arch} &> /tmp/ec2-bundle-vol.log &
+          nohup ec2-bundle-vol --batch -d /mnt -k #{ec2_pk_dest} -c #{ec2_cert_dest} -u #{env.account} -p #{image_name} -r #{arch} &> /tmp/ec2-bundle-vol.log &
           sleep 1
 
           echo "Creating image from instance volume..."
@@ -258,106 +70,54 @@ module Rubber
           export RUBYLIB=/usr/lib/site_ruby/
           unset RUBYOPT
           echo "Uploading image to S3..."
-          ec2-upload-bundle --batch -b #{@aws_env.image_bucket} -m /mnt/#{image_name}.manifest.xml -a #{@aws_env.access_key} -s #{@aws_env.secret_access_key}
+          ec2-upload-bundle --batch -b #{env.image_bucket} -m /mnt/#{image_name}.manifest.xml -a #{env.access_key} -s #{env.secret_access_key}
         CMD
 
-        image_location = "#{@aws_env.image_bucket}/#{image_name}.manifest.xml"
-        response = @ec2.register_image(:image_location => image_location)
-        return response.imageId
-      end
-
-      def describe_images(image_id=nil)
-        images = []
-        opts = {:owner_id => 'self'}
-        opts[:image_id] = image_id if image_id
-        response = @ec2.describe_images(opts)
-        response.imagesSet.item.each do |item|
-          image = {}
-          image[:id] = item.imageId
-          image[:location] = item.imageLocation
-          image[:root_device_type] = item.rootDeviceType
-          images << image
-        end if response.imagesSet
-        return images
+        image_location = "#{env.image_bucket}/#{image_name}.manifest.xml"
+        response = @compute_provider.register_image(image_name,
+                                                    "rubber bundled image",
+                                                    image_location)
+        return response.body["imageId"]
       end
 
       def destroy_image(image_id)
-        image = describe_images(image_id).first
+        image = @compute_provider.images.get(image_id)
         raise "Could not find image: #{image_id}, aborting destroy_image" if image.nil?
-        image_location = image[:location]
-        bucket = image_location.split('/').first
-        image_name = image_location.split('/').last.gsub(/\.manifest\.xml$/, '')
 
-        @ec2.deregister_image(:image_id => image_id)
+        location_parts = image.location.split('/')
+        bucket = location_parts.first
+        image_name = location_parts.last.gsub(/\.manifest\.xml$/, '')
 
-        s3_bucket = AWS::S3::Bucket.find(bucket)
-        s3_bucket.objects(:prefix => image_name).clone.each do |obj|
-          obj.delete
-        end
-        if s3_bucket.empty?
-          s3_bucket.delete
-        end
-      end
+        image.deregister
 
-      def destroy_spot_instance_request(request_id)
-        @ec2.cancel_spot_instance_requests :spot_instance_request_id => request_id
+        storage(bucket).walk_tree(image_name) do |f|
+          f.destroy
+        end
       end
 
       def describe_load_balancers(name=nil)
         lbs = []
-        opts = {}
-        opts[:load_balancer_names] = name if name
-        response = @ec2elb.describe_load_balancers(opts)
-        response.describeLoadBalancersResult.member.each do |member|
+        response = name.nil? ? @elb.load_balancers.all() : [@elb.load_balancers.get(name)].compact
+        response.each do |item|
           lb = {}
-          lb[:name] = member.loadBalancerName
-          lb[:dns_name] = member.dNSName
+          lb[:name] = item.id
+          lb[:dns_name] = item.dns_name
+          lb[:zones] = item.availability_zones
 
-          member.availabilityZones.member.each do |zone|
-            lb[:zones] ||= []
-            lb[:zones] << zone
-          end
-
-          member.listeners.member.each do |member|
+          item.listeners.each do |litem|
             listener = {}
-            listener[:protocol] = member.protocol
-            listener[:port] = member.loadBalancerPort
-            listener[:instance_port] = member.instancePort
+            listener[:protocol] = litem.protocol
+            listener[:port] = litem.lb_portPort
+            listener[:instance_port] = litem.instance_port
             lb[:listeners] ||= []
             lb[:listeners] << listener
           end
 
           lbs << lb
-        end if response.describeLoadBalancersResult
+        end
         return lbs
       end
 
-      def describe_spot_instance_requests(request_id=nil)
-        requests = []
-        opts = {}
-        opts[:spot_instance_request_id] = request_id if request_id
-        response = @ec2.describe_spot_instance_requests(opts)
-        response.spotInstanceRequestSet.item.each do |item|
-          request = {}
-          request[:id] = item.spotInstanceRequestId
-          request[:spot_price] = item.spotPrice
-          request[:state] = item.state
-          request[:created_at] = item.createTime
-          request[:type] = item.launchSpecification.instanceType
-          request[:image_id] = item.launchSpecification.imageId
-          request[:instance_id] = item.instanceId
-          requests << request
-        end if response.spotInstanceRequestSet
-        return requests
-      end
-
-      # resource_id is any Amazon resource ID (e.g., instance ID or volume ID)
-      # tags is a hash of tag_name => tag_value pairs
-      def create_tags(resource_id, tags)
-        # Tags needs to be an array of hashes, not one big hash, so break it down.
-        @ec2.create_tags(:resource_id => resource_id, :tag => tags.collect { |k, v| { k.to_s => v.to_s } })
-      end
-
     end
 
   end