sml-rubber 0.9.13 → 1.5.5

data/lib/rubber/cloud/aws.rb

@@ -15,13 +15,18 @@ module Rubber
         AWS::S3::Base.establish_connection!(:access_key_id => @aws_env.access_key, :secret_access_key => @aws_env.secret_access_key)
       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, :group_id => security_groups, :availability_zone => 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 = {}
@@ -37,6 +42,7 @@ module Rubber
             instance[:internal_host] = item.privateDnsName
             instance[:state] = item.instanceState.name
             instance[:zone] = item.placement.availabilityZone
+            instance[:platform] = item.platform || 'linux'
             instances << instance
           end
         end if response.reservationSet
@@ -214,12 +220,14 @@ module Rubber
         capistrano.put(File.read(ec2_pk), ec2_pk_dest)
         capistrano.put(File.read(ec2_cert), ec2_cert_dest)
 
-        arch = capistrano.capture "uname -m"
+        arch = capistrano.capture("uname -m").strip
         arch = case arch when /i\d86/ then "i386" else arch end
 
         capistrano.sudo_script "create_bundle", <<-CMD
+          rvm use system
           export RUBYLIB=/usr/lib/site_ruby/
-          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 &
+          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 &
           echo "Creating image from instance volume..."
           while true; do
             if ! ps ax | grep -q "[e]c2-bundle-vol"; then exit; fi
@@ -229,7 +237,9 @@ module Rubber
         CMD
 
         capistrano.sudo_script "register_bundle", <<-CMD
+          rvm use system
           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}
         CMD
@@ -255,6 +265,7 @@ module Rubber
 
       def destroy_image(image_id)
         image = describe_images(image_id).first
+        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$/, '')
@@ -270,6 +281,10 @@ module Rubber
         end
       end
 
+      def destroy_spot_instance_request(request_id)
+        @ec2.cancel_spot_instance_requests :spot_instance_request_id => request_id
+      end
+
       def describe_load_balancers(name=nil)
         lbs = []
         opts = {}
@@ -299,6 +314,25 @@ module Rubber
         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
+
     end
 
   end

data/lib/rubber/dns/base.rb

@@ -3,65 +3,80 @@ module Rubber
 
     class Base
 
-      attr_reader :env
+      attr_reader :env, :provider_env, :provider_name
 
-      def initialize(env)
+      def initialize(env, provider_name)
         @env = env
+        @provider_name = provider_name
+        @provider_env = @env.dns_providers[provider_name]
       end
 
       def update(host, ip)
         if up_to_date(host, ip)
           puts "IP has not changed for #{host}, not updating dynamic DNS"
         else
-          if ! host_exists?(host)
+          if find_host_records(:host => host).size == 0
             puts "Creating dynamic DNS: #{host} => #{ip}"
-            create_host_record(host, ip)
+            create_host_record(:host => host, :data => ip)
           else
             puts "Updating dynamic DNS: #{host} => #{ip}"
-            update_host_record(host, ip)
+            update_host_record({:host => host}, {:host => host, :data => ip})
           end
         end
       end
 
       def destroy(host)
-        if host_exists?(host)
+        if find_host_records(:host => host).size != 0
           puts "Destroying dynamic DNS record: #{host}"
-          destroy_host_record(host)
+          destroy_host_record(:host => host)
         end
       end
 
-      def hostname(host)
-        "#{host}.#{@env.domain}"
-      end
-
       def up_to_date(host, ip)
-        # This queries dns server directly instead of using hosts file
-        current_ip = nil
-        Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
-          current_ip = dns.getaddress(hostname(host)).to_s rescue nil
-        end
-        return ip == current_ip
+        find_host_records(:host => host).any? {|host| host[:data] == ip}
       end
 
-      def nameserver()
-        raise "nameserver not implemented"
+      def create_host_record(opts = {})
+        raise "create_host_record not implemented"
       end
 
-      def host_exists?(host)
-        raise "host_exists? not implemented"
+      def find_host_records(opts = {})
+        raise "find_host_records not implemented"
       end
 
-      def create_host_record(host, ip)
-        raise "create_host_record not implemented"
+      def update_host_record(old_opts={}, new_opts={})
+        raise "update_host_record not implemented"
       end
 
-      def destroy_host_record(host)
+      def destroy_host_record(opts = {})
         raise "destroy_host_record not implemented"
       end
 
-      def update_host_record(host, ip)
-        raise "update_host_record not implemented"
+      def host_records_equal?(lhs_opts = {}, rhs_opts = {})
+        lhs = setup_opts(lhs_opts)
+        rhs = setup_opts(rhs_opts)
+        [lhs, rhs].each {|h| h.delete(:id); h.delete(:priority) if h[:priority] == 0}
+        lhs == rhs
+      end
+
+      def setup_opts(opts, required=[])
+        default_opts = {:domain => @env.domain,
+                        :type => @provider_env['type'] || @provider_env.record_type || 'A',
+                        :ttl => @provider_env.ttl || 300}
+        
+        if opts.delete(:no_defaults)
+          actual_opts = Rubber::Util::symbolize_keys(opts)
+        else
+          actual_opts = default_opts.merge(Rubber::Util::symbolize_keys(opts))
+        end
+
+        required.each do |r|
+          raise "Missing required options: #{r}" unless actual_opts[r]
+        end
+
+        return actual_opts
       end
+      
 
     end
 

data/lib/rubber/dns/dyndns.rb

@@ -4,10 +4,9 @@ module Rubber
     class Dyndns < Base
 
       def initialize(env)
-        super(env)
-        @dyndns_env = env.dns_providers.dyndns
-        @user, @pass = @dyndns_env.user, @dyndns_env.password
-        @update_url = @dyndns_env.update_url || 'https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
+        super(env, 'dyndns')
+        @user, @pass = provider_env.user, provider_env.password
+        @update_url = provider_env.update_url || 'https://members.dyndns.org/nic/update?hostname=%host%&myip=%ip%'
         @update_url = @update_url.gsub(/%([^%]+)%/, '#{\1}')
       end
 
@@ -15,10 +14,22 @@ module Rubber
         "ns1.mydyndns.org"
       end
 
-      def host_exists?(host)
+      def up_to_date(host, ip)
+        # This queries dns server directly instead of using hosts file
+        current_ip = nil
+        Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
+          current_ip = dns.getaddress("#{host}.#{provider_env.domain}").to_s rescue nil
+        end
+        return ip == current_ip
+      end
+      
+      def find_host_records(opts={})
+        opts = setup_opts(opts, [:host, :domain])
+        hostname = "#{opts[:host]}.#{opts[:domain]}"
         begin
           Resolv::DNS.open(:nameserver => [nameserver], :search => [], :ndots => 1) do |dns|
-            dns.getresource(hostname(host), Resolv::DNS::Resource::IN::A)
+            r = dns.getresource(hostname, Resolv::DNS::Resource::IN::A)
+            result = [{:host =>host, :data => r.address}]
           end
         rescue
           raise "Domain needs to exist in dyndns as an A record before record can be updated"
@@ -26,16 +37,20 @@ module Rubber
         return true
       end
 
-      def create_host_record(host, ip)
+      def create_host_record(opts={})
         puts "WARNING: No create record available for dyndns, you need to do so manually"
       end
 
-      def destroy_host_record(host)
+      def destroy_host_record(opts={})
         puts "WARNING: No destroy record available for dyndns, you need to do so manually"
       end
 
-      def update_host_record(host, ip)
-        host = hostname(host)
+      def update_host_record(old_opts={}, new_opts={})
+        old_opts = setup_opts(opts, [:host, :domain])
+        new_opts = setup_opts(opts, [:data])
+        
+        host = hostname(old_opts[:host])
+        ip = new_opts[:data]
         update_url = eval('%Q{' + @update_url + '}')
 
         # This header is required by dyndns.org

data/lib/rubber/dns/nettica.rb

@@ -5,51 +5,112 @@ module Rubber
     class Nettica < Base
 
       def initialize(env)
-        super(env)
-        @nettica_env = @env.dns_providers.nettica
-        @client = ::Nettica::Client.new(@nettica_env.user, @nettica_env.password)
-        @ttl = (@nettica_env.ttl || 300).to_i
-        @record_type = @nettica_env.record_type || "A"
+        super(env, "nettica")
+        @client = ::Nettica::Client.new(provider_env.user, provider_env.password)
       end
 
-      def nameserver
-        "dns1.nettica.com"
+      def check_status(response)
+        code = case
+          when response.respond_to?(:status)
+            response.status
+          when response.respond_to?(:result)
+            response.result.status
+          else
+            500
+        end
+        if code < 200 || code > 299
+          msg = "Failed to access nettica api (http_status=#{code})"
+          msg += ", check dns_providers.nettica.user/password in rubber.yml" if code == 401
+          raise msg
+        end
+        return response
       end
 
-      def host_exists?(host)
-        domain_info = @client.list_domain(env.domain)
-        raise "Domain needs to exist in nettica before records can be updated" unless domain_info.record
-        return domain_info.record.any? { |r| r.hostName == host }
+      def find_host_records(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+
+        result = []
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+
+        domain_info = find_or_create_zone(opts[:domain])
+
+        domain_info.record.each do |h|
+          keep = true
+          if hn && h.hostName != hn && hn != '*'
+            keep = false
+          end
+          if ht && h.recordType != ht && ht != '*'
+            keep = false
+          end
+          if hd && h.data != hd
+            keep = false
+          end
+          result << record_to_opts(h) if keep
+        end
+
+        return result
       end
 
-      def create_host_record(host, ip)
-        new = @client.create_domain_record(env.domain, host, @record_type, ip, @ttl, 0)
-        @client.add_record(new)
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        find_or_create_zone(opts[:domain])
+        record = opts_to_record(opts)
+        check_status @client.add_record(record)
       end
 
-      def destroy_host_record(host)
-        old_record = @client.list_domain(env.domain).record.find {|r| r.hostName == host }
-        old = @client.create_domain_record(env.domain, host, old_record.recordType, old_record.data, old_record.tTL, old_record.priority)
-        @client.delete_record(old)
+      def destroy_host_record(opts = {})
+        find_host_records(opts).each do |h|
+          record = opts_to_record(h)
+          check_status @client.delete_record(record)
+        end
       end
 
-      def update_host_record(host, ip)
-        old_record = @client.list_domain(env.domain).record.find {|r| r.hostName == host }
-        update_record(host, ip, old_record)
+      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), [])
+        find_host_records(old_opts).each do |h|
+          old_record = opts_to_record(h)
+          new_record = opts_to_record(h.merge(new_opts))
+          check_status @client.update_record(old_record, new_record)
+        end
       end
 
-      # update the top level domain record which has an empty hostName
-      def update_domain_record(ip)
-        old_record = @client.list_domain(env.domain).record.find {|r| r.hostName == '' and r.recordType == 'A' and r.data =~ /\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/}
-        update_record('', ip, old_record)
+      private
+
+      def find_or_create_zone(domain)
+        domain_info = @client.list_domain(domain)
+        if domain_info.record
+          check_status domain_info
+        else
+          check_status @client.create_zone(domain)
+          domain_info = check_status @client.list_domain(domain)
+          raise "Could not create zone in nettica: #{domain}" unless domain_info.record
+        end
+        return domain_info
       end
 
-      def update_record(host, ip, old_record)
-        old = @client.create_domain_record(env.domain, host, old_record.recordType, old_record.data, old_record.tTL, old_record.priority)
-        new = @client.create_domain_record(env.domain, host, @record_type, ip, @ttl, 0)
-        @client.update_record(old, new)
+      def opts_to_record(opts)
+        record = @client.create_domain_record(opts[:domain],
+                                              opts[:host],
+                                              opts[:type],
+                                              opts[:data],
+                                              opts[:ttl],
+                                              opts[:priority] || 0)
+        return record
       end
 
+      def record_to_opts(record)
+        opts = {}
+        opts[:host] = record.hostName || ''
+        opts[:domain] = record.domainName
+        opts[:type] = record.recordType
+        opts[:data] = record.data if record.data
+        opts[:ttl] = record.tTL if record.tTL
+        opts[:priority] = record.priority if record.priority
+        return opts
+      end
     end
 
   end

data/lib/rubber/dns/zerigo.rb

@@ -1,118 +1,112 @@
 require 'rubygems'
-require 'httparty'
+
+begin
+  require 'zerigo_dns'
+rescue LoadError
+  puts "Missing the zerigo_dns gem.  Install with `sudo gem install zerigo_dns`."
+  exit(-1)
+end
 
 module Rubber
   module Dns
 
+    class Zerigo < Base
 
-    class Zone
-      include HTTParty
-      format :xml
-
-      def initialize(customer_id, email, token, domain)
-        self.class.basic_auth email, token
-        self.class.base_uri "https://ns.zerigo.com/accounts/#{customer_id}"
-        @domain = domain
-        refresh()
-      end
-
-      def hosts
-        hosts = self.class.get("/zones/#{@zone['id']}/hosts.xml")
-        return hosts['hosts']
-      end
-
-      def host(hostname)
-        hosts = self.class.get("/zones/#{@zone['id']}/hosts.xml?fqdn=#{hostname}.#{@domain}")
-        return (hosts['hosts'] || []).first
-      end
-
-      def new_host
-        self.class.get("/zones/#{@zone['id']}/hosts/new.xml")['host']
-      end
-
-      def create_host(host)
-        self.class.post("/zones/#{@zone['id']}/hosts.xml", :body => {:host => host})
-      end
-
-      def update_host(host)
-        host_id = host['id']
-        self.class.put("/zones/#{@zone['id']}/hosts/#{host_id}.xml", :body => {:host => host})
-      end
-
-      def delete_host(hostname)
-        host_id = host(hostname)['id']
-        self.class.delete("/zones/#{@zone['id']}/hosts/#{host_id}.xml")
-      end
-
-      def refresh
-        zone_id = @zone['id'] rescue nil
-        if zone_id
-          @zone = self.class.get("/zones/#{zone_id}.xml")
-        else
-          zones = self.class.get('/zones.xml')
-          @zone = zones["zones"].find {|z| z["domain"] == @domain }
+      def initialize(env)
+        super(env, "zerigo")
+
+        ::Zerigo::DNS::Base.user = provider_env.email
+        ::Zerigo::DNS::Base.password = provider_env.token
+      end
+
+      def host_to_opts(host)
+        opts = {}
+        opts[:id] = host.id
+        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
+
+      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 find_hosts(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        result = []
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
+        params = { :zone_id => zone.id }
+
+        hn = opts[:host]
+        ht = opts[:type]
+        hd = opts[:data]
+        has_host = hn && hn != '*'
+        if has_host
+          url = ""
+          url << "#{hn}." if hn.strip.size > 0
+          url << "#{opts[:domain]}"
+          params[:fqdn] = url
         end
-      end
-
-      def data
-        return @zone
-      end
 
-      protected
-
-      def zones()
-        self.class.get('/zones.xml')
-      end
-
-      def zone(domain_name)
-        zone =  zones
-        return zone
-      end
-      
-    end
-    
-    class Zerigo < Base
+        begin
+          hosts = ::Zerigo::DNS::Host.find(:all, :params=> params)
+
+          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 << h if keep
+          end if hosts
+        rescue ActiveResource::ResourceNotFound => e
+        end
 
-      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)
+        return result
       end
 
-      def nameserver
-        "a.ns.zerigo.net"
+      def find_host_records(opts = {})
+        hosts = find_hosts(opts)
+        result = hosts.collect {|h| host_to_opts(h).merge(:domain => opts[:domain]) }
+        return result
       end
 
-      def host_exists?(host)
-        @zone.host(host)
+      def create_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :data, :domain, :type, :ttl])
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
+        ::Zerigo::DNS::Host.create(opts_to_host(opts).merge(:zone_id => zone.id))
       end
 
-      def create_host_record(host, ip)
-        host = @zone.new_host()
-        host['host-type'] =  @record_type
-        host['ttl'] = @ttl
-        host['hostname'] = host
-        host['data'] = ip
-        @zone.create_host(host)
-      end
+      def destroy_host_record(opts = {})
+        opts = setup_opts(opts, [:host, :domain])
+        zone = ::Zerigo::DNS::Zone.find_or_create(opts[:domain])
 
-      def destroy_host_record(host)
-        @zone.delete_host(host)
+        find_hosts(opts).each do |h|
+          h.destroy || raise("Failed to destroy #{h.hostname}")
+        end
       end
 
-      def update_host_record(host, ip)
-        old = @zone.host(host)
-        old['data'] = ip
-        @zone.update_host(old)
-      end
+      def update_host_record(old_opts={}, new_opts={})
+        old_opts = setup_opts(old_opts, [:host, :domain])
+        new_opts = setup_opts(new_opts, [:host, :domain, :type, :data])
+        zone = ::Zerigo::DNS::Zone.find_or_create(old_opts[:domain])
 
-      # 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)
+        find_hosts(old_opts).each do |h|
+          opts_to_host(new_opts).each do |k, v|
+            h.send("#{k}=", v)
+          end
+          h.save || raise("Failed to update host #{h.hostname}, #{h.errors.full_messages.join(', ')}")
+        end
       end
 
     end